test(v1.x): consistent appHash between commits

app/consistent_apphash_test.go

@@ -0,0 +1,208 @@
+package app_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/celestiaorg/celestia-app/app"
+	"github.com/celestiaorg/celestia-app/app/encoding"
+	"github.com/celestiaorg/celestia-app/pkg/appconsts"
+	appns "github.com/celestiaorg/celestia-app/pkg/namespace"
+	"github.com/celestiaorg/celestia-app/pkg/user"
+	testutil "github.com/celestiaorg/celestia-app/test/util"
+	"github.com/celestiaorg/celestia-app/test/util/blobfactory"
+	"github.com/cosmos/cosmos-sdk/codec"
+	"github.com/cosmos/cosmos-sdk/crypto/hd"
+	"github.com/cosmos/cosmos-sdk/crypto/keyring"
+	"github.com/cosmos/cosmos-sdk/crypto/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
+	"github.com/stretchr/testify/require"
+	abci "github.com/tendermint/tendermint/abci/types"
+	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
+	"github.com/tendermint/tendermint/proto/tendermint/version"
+	coretypes "github.com/tendermint/tendermint/types"
+)
+
+type SdkTx struct {
+	sdkMsgs   []sdk.Msg
+	txOptions []user.TxOption
+}
+
+type BlobTx struct {
+	author    string
+	blobs     []*tmproto.Blob
+	txOptions []user.TxOption
+}
+
+// TestConsistentAppHash executes a set of txs, generates an app hash,
+// and compares it against a previously generated hash from the same set of transactions.
+// App hashes across different commits should be consistent.
+func TestConsistentAppHash(t *testing.T) {
+	// App hash produced from executing txs on this branch
+	expectedAppHash := []byte{9, 208, 117, 101, 108, 61, 146, 58, 26, 190, 199, 124, 76, 178, 84, 74, 54, 159, 76, 187, 2, 169, 128, 87, 70, 78, 8, 192, 28, 144, 116, 117}
+
+	// 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)
+	accountNames := make([]string, 0, len(recs))
+
+	// Get the name of the records
+	for _, rec := range recs {
+		accountNames = append(accountNames, rec.Name)
+	}
+
+	// Apply genesis state to the app.
+	_, _, err = testutil.SetupDeterministicGenesisState(testApp, pubKeys, 1_000_000_000, app.DefaultInitialConsensusParams())
+	require.NoError(t, err)
+
+	// Query keyring account infos
+	accountInfos := queryAccountInfo(testApp, accountNames, kr)
+
+	// Create accounts for the signer
+	accounts := make([]*user.Account, 0, len(accountInfos))
+	for i, accountInfo := range accountInfos {
+		account := user.NewAccount(accountNames[i], accountInfo.AccountNum, accountInfo.Sequence)
+		accounts = append(accounts, account)
+	}
+
+	// Create a signer with keyring accounts
+	signer, err := user.NewTxSigner(kr, enc.TxConfig, testutil.ChainID, appconsts.LatestVersion, accounts...)
+	require.NoError(t, err)
+
+	amount := sdk.NewCoins(sdk.NewCoin(app.BondDenom, sdk.NewIntFromUint64(1000)))
+
+	// Create an SDK Tx
+	sdkTx := SdkTx{
+		sdkMsgs: []sdk.Msg{
+			banktypes.NewMsgSend(signer.Account(accountNames[0]).Address(),
+				signer.Account(accountNames[1]).Address(),
+				amount),
+		},
+		txOptions: blobfactory.DefaultTxOpts(),
+	}
+
+	// Create a Blob Tx
+	blobTx := BlobTx{
+		author:    accountNames[2],
+		blobs:     []*tmproto.Blob{New(fixedNamespace(), []byte{1}, appconsts.DefaultShareVersion)},
+		txOptions: blobfactory.DefaultTxOpts(),
+	}
+
+	// Create SDK Tx
+	rawSdkTx, err := signer.CreateTx(sdkTx.sdkMsgs, sdkTx.txOptions...)
+	require.NoError(t, err)
+
+	// Create Blob Tx
+	rawBlobTx, _, err := signer.CreatePayForBlobs(blobTx.author, blobTx.blobs, blobTx.txOptions...)
+	require.NoError(t, err)
+
+	// BeginBlock
+	header := tmproto.Header{
+		Version: version.Consensus{App: 1},
+		Height:  testApp.LastBlockHeight() + 1,
+	}
+	testApp.BeginBlock(abci.RequestBeginBlock{Header: header})
+
+	// Deliver SDK Tx
+	resp := testApp.DeliverTx(abci.RequestDeliverTx{Tx: rawSdkTx})
+	require.EqualValues(t, 0, resp.Code, resp.Log)
+
+	// Deliver Blob Tx
+	blob, isBlobTx := coretypes.UnmarshalBlobTx(rawBlobTx)
+	require.True(t, isBlobTx)
+	resp = testApp.DeliverTx(abci.RequestDeliverTx{Tx: blob.Tx})
+	require.EqualValues(t, 0, resp.Code, resp.Log)
+
+	// EndBlock
+	testApp.EndBlock(abci.RequestEndBlock{Height: header.Height})
+
+	// Commit the state
+	testApp.Commit()
+
+	// Get the app hash
+	appHash := testApp.LastCommitID().Hash
+
+	// Require that the app hash is equal to the app hash produced on a different commit
+	require.Equal(t, expectedAppHash, appHash)
+}
+
+// fixedNamespace returns a hardcoded namespace
+func fixedNamespace() 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
+}
+
+func getAddress(account string, kr keyring.Keyring) sdk.AccAddress {
+	rec, err := kr.Key(account)
+	if err != nil {
+		panic(err)
+	}
+	addr, err := rec.GetAddress()
+	if err != nil {
+		panic(err)
+	}
+	return addr
+}
+
+func queryAccountInfo(capp *app.App, accs []string, kr keyring.Keyring) []blobfactory.AccountInfo {
+	infos := make([]blobfactory.AccountInfo, len(accs))
+	for i, acc := range accs {
+		addr := getAddress(acc, kr)
+		accI := testutil.DirectQueryAccount(capp, addr)
+		infos[i] = blobfactory.AccountInfo{
+			AccountNum: accI.GetAccountNumber(),
+			Sequence:   accI.GetSequence(),
+		}
+	}
+	return infos
+}
+
+// New creates a new tmproto.Blob from the provided data
+func New(ns appns.Namespace, blob []byte, shareVersion uint8) *tmproto.Blob {
+	return &tmproto.Blob{
+		NamespaceId:      ns.ID,
+		Data:             blob,
+		ShareVersion:     uint32(shareVersion),
+		NamespaceVersion: uint32(ns.Version),
+	}
+}

test/util/blobfactory/test_util.go

@@ -2,6 +2,7 @@ package blobfactory
 
 import (
 	"github.com/celestiaorg/celestia-app/pkg/appconsts"
+	"github.com/celestiaorg/celestia-app/pkg/user"
 	"github.com/celestiaorg/celestia-app/test/util/testfactory"
 	blobtypes "github.com/celestiaorg/celestia-app/x/blob/types"
 	"github.com/cosmos/cosmos-sdk/client"
@@ -11,6 +12,18 @@ import (
 	coretypes "github.com/tendermint/tendermint/types"
 )
 
+func DefaultTxOpts() []user.TxOption {
+	return FeeTxOpts(10_000_000)
+}
+
+func FeeTxOpts(gas uint64) []user.TxOption {
+	fee := uint64(float64(gas)*appconsts.DefaultMinGasPrice) + 1
+	return []user.TxOption{
+		user.SetFee(fee),
+		user.SetGasLimit(gas),
+	}
+}
+
 func GenerateManyRawSendTxs(txConfig client.TxConfig, count int) []coretypes.Tx {
 	const acc = "signer"
 	kr := testfactory.GenerateKeyring(acc)

test/util/genesis/accounts.go

@@ -1,6 +1,7 @@
 package genesis
 
 import (
+	"errors"
 	"fmt"
 	mrand "math/rand"
 	"time"
@@ -15,34 +16,41 @@ import (
 	"github.com/tendermint/tendermint/crypto"
 )
 
-type Account struct {
+const (
+	DefaultInitialBalance = 1e15 // 1 billion TIA
+)
+
+// KeyringAccount represents a user account on the Celestia network.
+// Either the name, if using the genesis keyring, or an address
+// needs to be provided
+type KeyringAccount struct {
 	Name          string
 	InitialTokens int64
 }
 
-func NewAccounts(initBal int64, names ...string) []Account {
-	accounts := make([]Account, len(names))
+func NewKeyringAccounts(initBal int64, names ...string) []KeyringAccount {
+	accounts := make([]KeyringAccount, len(names))
 	for i, name := range names {
-		accounts[i] = Account{
+		accounts[i] = KeyringAccount{
 			Name:          name,
 			InitialTokens: initBal,
 		}
 	}
 	return accounts
 }
 
-func (ga *Account) ValidateBasic() error {
+func (ga *KeyringAccount) ValidateBasic() error {
 	if ga.Name == "" {
-		return fmt.Errorf("name cannot be empty")
+		return errors.New("name cannot be empty")
 	}
 	if ga.InitialTokens <= 0 {
-		return fmt.Errorf("initial tokens must be positive")
+		return errors.New("initial tokens must be positive")
 	}
 	return nil
 }
 
 type Validator struct {
-	Account
+	KeyringAccount
 	Stake int64
 
 	// ConsensusKey is the key used by the validator to sign votes.
@@ -53,29 +61,29 @@ type Validator struct {
 func NewDefaultValidator(name string) Validator {
 	r := mrand.New(mrand.NewSource(time.Now().UnixNano()))
 	return Validator{
-		Account: Account{
+		KeyringAccount: KeyringAccount{
 			Name:          name,
-			InitialTokens: 999_999_999_999_999_999,
+			InitialTokens: DefaultInitialBalance,
 		},
-		Stake:        99_999_999_999_999_999, // save some tokens for fees
+		Stake:        DefaultInitialBalance / 2, // save some tokens for fees
 		ConsensusKey: GenerateEd25519(NewSeed(r)),
 		NetworkKey:   GenerateEd25519(NewSeed(r)),
 	}
 }
 
 // ValidateBasic performs stateless validation on the validitor
 func (v *Validator) ValidateBasic() error {
-	if err := v.Account.ValidateBasic(); err != nil {
+	if err := v.KeyringAccount.ValidateBasic(); err != nil {
 		return err
 	}
 	if v.Stake <= 0 {
-		return fmt.Errorf("stake must be positive")
+		return errors.New("stake must be positive")
 	}
 	if v.ConsensusKey == nil {
-		return fmt.Errorf("consensus key cannot be empty")
+		return errors.New("consensus key cannot be empty")
 	}
 	if v.Stake > v.InitialTokens {
-		return fmt.Errorf("stake cannot be greater than initial tokens")
+		return errors.New("stake cannot be greater than initial tokens")
 	}
 	return nil
 }
@@ -115,7 +123,7 @@ func (v *Validator) GenTx(ecfg encoding.Config, kr keyring.Keyring, chainID stri
 		return nil, err
 	}
 
-	fee := sdk.NewCoins(sdk.NewCoin(app.BondDenom, sdk.NewInt(1)))
+	fee := sdk.NewCoins(sdk.NewCoin(app.BondDenom, sdk.NewInt(20000)))
 	txBuilder := ecfg.TxConfig.NewTxBuilder()
 	err = txBuilder.SetMsgs(createValMsg)
 	if err != nil {