Merge tag 'v0.47.7' into release/v0.47.x-neutron

Release v0.47.7

CHANGELOG.md

@@ -37,6 +37,19 @@ Ref: https://keepachangelog.com/en/1.0.0/
 
 ## [Unreleased]
 
+## [v0.47.7](https://github.com/cosmos/cosmos-sdk/releases/tag/v0.47.7) - 2023-12-20
+
+### Improvements
+
+* (x/gov) [#18707](https://github.com/cosmos/cosmos-sdk/pull/18707) Improve genesis validation. 
+* (server) [#18478](https://github.com/cosmos/cosmos-sdk/pull/18478) Add command flag to disable colored logs.
+
+### Bug Fixes
+
+* (baseapp) [#18609](https://github.com/cosmos/cosmos-sdk/issues/18609) Fixed accounting in the block gas meter after BeginBlock and before DeliverTx, ensuring transaction processing always starts with the expected zeroed out block gas meter.
+* (server) [#18537](https://github.com/cosmos/cosmos-sdk/pull/18537) Fix panic when defining minimum gas config as `100stake;100uatom`. Use a `,` delimiter instead of `;`. Fixes the server config getter to use the correct delimiter.
+* (client/tx) [#18472](https://github.com/cosmos/cosmos-sdk/pull/18472) Utilizes the correct Pubkey when simulating a transaction.
+
 ## [v0.47.6](https://github.com/cosmos/cosmos-sdk/releases/tag/v0.47.6) - 2023-11-14
 
 ### Features

RELEASE_NOTES.md

@@ -1,17 +1,17 @@
-# Cosmos SDK v0.47.6 Release Notes
+# Cosmos SDK v0.47.7 Release Notes
 
 💬 [**Release Discussion**](https://github.com/orgs/cosmos/discussions/categories/announcements)
 
 ## 🚀 Highlights
 
 v0.50 is there, the v0.47.x line is now supported for bug fixes only, as per our release policy.
-Start integrating with [Cosmos SDK Eden (v0.50)](https://github.com/cosmos/cosmos-sdk/releases/tag/v0.50.1) and enjoy and the new features and performance improvements.
+Start integrating with [Cosmos SDK Eden (v0.50)](https://github.com/cosmos/cosmos-sdk/releases/tag/v0.50.2) and enjoy and the new features and performance improvements.
 
-For this 6th patch release of the `v0.47.x` line, some of the notable changes include:
+For this 7th patch release of the `v0.47.x` line, some of the notable changes include:
 
-* The gRPC and API server are both started in standalone mode (CometBFT out of process)
-* Fix the default prepare proposal handler to better match CometBFT ABCI specification
+* A bug fix in the `app.toml` parsing for the `minimum-gas-prices` parameter.
+* A bug fix to properly simulate a transaction when using a multisig. 
 
-Check out the [changelog](https://github.com/cosmos/cosmos-sdk/blob/v0.47.5/CHANGELOG.md) for an exhaustive list of changes or [compare changes](https://github.com/cosmos/cosmos-sdk/compare/v0.47.5...v0.47.6) from last release.
+Check out the [changelog](https://github.com/cosmos/cosmos-sdk/blob/v0.47.5/CHANGELOG.md) for an exhaustive list of changes or [compare changes](https://github.com/cosmos/cosmos-sdk/compare/v0.47.6...v0.47.7) from last release.
 
-Refer to the [upgrading guide](https://github.com/cosmos/cosmos-sdk/blob/release/v0.50.x/UPGRADING.md) when migrating from `v0.47.x` to `v0.50.1`.
+Refer to the [upgrading guide](https://github.com/cosmos/cosmos-sdk/blob/release/v0.50.x/UPGRADING.md) when migrating from `v0.47.x` to `v0.50.x`.

baseapp/abci.go

@@ -206,6 +206,10 @@ func (app *BaseApp) BeginBlock(req abci.RequestBeginBlock) (res abci.ResponseBeg
 		}
 	}
 
+	// Reset the gas meter so that the AnteHandlers aren't required to
+	gasMeter = app.getBlockGasMeter(app.deliverState.ctx)
+	app.deliverState.ctx = app.deliverState.ctx.WithBlockGasMeter(gasMeter)
+
 	return res
 }
 

baseapp/baseapp_test.go

@@ -158,6 +158,41 @@ func NewBaseAppSuiteWithSnapshots(t *testing.T, cfg SnapshotsConfig, opts ...fun
 	return suite
 }
 
+func TestAnteHandlerGasMeter(t *testing.T) {
+	// run BeginBlock and assert that the gas meter passed into the first Txn's AnteHandlers is zeroed out
+	anteOpt := func(bapp *baseapp.BaseApp) {
+		bapp.SetAnteHandler(func(ctx sdk.Context, tx sdk.Tx, simulate bool) (newCtx sdk.Context, err error) {
+			gasMeter := ctx.BlockGasMeter()
+			require.NotNil(t, gasMeter)
+			require.Equal(t, sdk.Gas(0), gasMeter.GasConsumed())
+			return ctx, nil
+		})
+	}
+	// set the beginBlocker to use some gas
+	beginBlockerOpt := func(bapp *baseapp.BaseApp) {
+		bapp.SetBeginBlocker(func(ctx sdk.Context, req abci.RequestBeginBlock) abci.ResponseBeginBlock {
+			ctx.BlockGasMeter().ConsumeGas(1, "beginBlocker gas consumption")
+			return abci.ResponseBeginBlock{}
+		})
+	}
+
+	suite := NewBaseAppSuite(t, anteOpt, beginBlockerOpt)
+
+	_ = suite.baseApp.InitChain(abci.RequestInitChain{
+		ConsensusParams: &tmproto.ConsensusParams{},
+	})
+
+	// Run BeginBlock to consume some gas
+	header := tmproto.Header{Height: 1}
+	suite.baseApp.BeginBlock(abci.RequestBeginBlock{Header: header})
+
+	// Run our first Tx (make sure the AnteHandler doesn't see gas consumed in BeginBlock
+	tx := newTxCounter(t, suite.txConfig, 0, 0)
+	txBytes, err := suite.txConfig.TxEncoder()(tx)
+	require.NoError(t, err)
+	suite.baseApp.DeliverTx(abci.RequestDeliverTx{Tx: txBytes})
+}
+
 func TestLoadVersion(t *testing.T) {
 	logger := defaultLogger()
 	pruningOpt := baseapp.SetPruning(pruningtypes.NewPruningOptions(pruningtypes.PruningNothing))

client/flags/flags.go

@@ -85,8 +85,9 @@ const (
 	FlagOutput = tmcli.OutputFlag
 
 	// Tendermint logging flags
-	FlagLogLevel  = "log_level"
-	FlagLogFormat = "log_format"
+	FlagLogLevel   = "log_level"
+	FlagLogFormat  = "log_format"
+	FlagLogNoColor = "log_no_color"
 )
 
 // LineBreak can be included in a command list to provide a blank line

client/tx/factory.go

@@ -15,6 +15,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/client/flags"
 	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
 	"github.com/cosmos/cosmos-sdk/crypto/keyring"
+	"github.com/cosmos/cosmos-sdk/crypto/keys/multisig"
 	"github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
 	cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
@@ -34,6 +35,7 @@ type Factory struct {
 	timeoutHeight      uint64
 	gasAdjustment      float64
 	chainID            string
+	fromName           string
 	offline            bool
 	generateOnly       bool
 	memo               string
@@ -86,6 +88,7 @@ func NewFactoryCLI(clientCtx client.Context, flagSet *pflag.FlagSet) (Factory, e
 		accountRetriever:   clientCtx.AccountRetriever,
 		keybase:            clientCtx.Keyring,
 		chainID:            clientCtx.ChainID,
+		fromName:           clientCtx.FromName,
 		offline:            clientCtx.Offline,
 		generateOnly:       clientCtx.GenerateOnly,
 		gas:                gasSetting.Gas,
@@ -414,10 +417,8 @@ func (f Factory) BuildSimTx(msgs ...sdk.Msg) ([]byte, error) {
 	// Create an empty signature literal as the ante handler will populate with a
 	// sentinel pubkey.
 	sig := signing.SignatureV2{
-		PubKey: pk,
-		Data: &signing.SingleSignatureData{
-			SignMode: f.signMode,
-		},
+		PubKey:   pk,
+		Data:     f.getSimSignatureData(pk),
 		Sequence: f.Sequence(),
 	}
 	if err := txb.SetSignatures(sig); err != nil {
@@ -438,16 +439,13 @@ func (f Factory) getSimPK() (cryptotypes.PubKey, error) {
 		pk cryptotypes.PubKey = &secp256k1.PubKey{} // use default public key type
 	)
 
-	// Use the first element from the list of keys in order to generate a valid
-	// pubkey that supports multiple algorithms.
 	if f.simulateAndExecute && f.keybase != nil {
-		records, _ := f.keybase.List()
-		if len(records) == 0 {
-			return nil, errors.New("cannot build signature for simulation, key records slice is empty")
+		record, err := f.keybase.Key(f.fromName)
+		if err != nil {
+			return nil, err
 		}
 
-		// take the first record just for simulation purposes
-		pk, ok = records[0].PubKey.GetCachedValue().(cryptotypes.PubKey)
+		pk, ok = record.PubKey.GetCachedValue().(cryptotypes.PubKey)
 		if !ok {
 			return nil, errors.New("cannot build signature for simulation, failed to convert proto Any to public key")
 		}
@@ -456,6 +454,26 @@ func (f Factory) getSimPK() (cryptotypes.PubKey, error) {
 	return pk, nil
 }
 
+// getSimSignatureData based on the pubKey type gets the correct SignatureData type
+// to use for building a simulation tx.
+func (f Factory) getSimSignatureData(pk cryptotypes.PubKey) signing.SignatureData {
+	multisigPubKey, ok := pk.(*multisig.LegacyAminoPubKey)
+	if !ok {
+		return &signing.SingleSignatureData{SignMode: f.signMode}
+	}
+
+	multiSignatureData := make([]signing.SignatureData, 0, multisigPubKey.Threshold)
+	for i := uint32(0); i < multisigPubKey.Threshold; i++ {
+		multiSignatureData = append(multiSignatureData, &signing.SingleSignatureData{
+			SignMode: f.SignMode(),
+		})
+	}
+
+	return &signing.MultiSignatureData{
+		Signatures: multiSignatureData,
+	}
+}
+
 // Prepare ensures the account defined by ctx.GetFromAddress() exists and
 // if the account number and/or the account sequence number are zero (not set),
 // they will be queried for and set on the provided Factory.

client/tx/factory_test.go

@@ -1,34 +1,120 @@
-package tx_test
+package tx
 
 import (
 	"testing"
 
-	"github.com/cosmos/cosmos-sdk/client"
-	"github.com/cosmos/cosmos-sdk/client/tx"
 	"github.com/stretchr/testify/require"
+
+	"github.com/cosmos/cosmos-sdk/client"
+	"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/keys/multisig"
+	"github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
+	"github.com/cosmos/cosmos-sdk/crypto/types"
+	"github.com/cosmos/cosmos-sdk/testutil/testdata"
+	"github.com/cosmos/cosmos-sdk/types/tx/signing"
+
+	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
+	cryptocodec "github.com/cosmos/cosmos-sdk/crypto/codec"
 )
 
-func TestFactoryPrepate(t *testing.T) {
+func TestFactoryPrepare(t *testing.T) {
 	t.Parallel()
 
-	factory := tx.Factory{}
+	factory := Factory{}
 	clientCtx := client.Context{}
 
 	output, err := factory.Prepare(clientCtx.WithOffline(true))
 	require.NoError(t, err)
 	require.Equal(t, output, factory)
 
-	factory = tx.Factory{}.WithAccountRetriever(client.MockAccountRetriever{ReturnAccNum: 10, ReturnAccSeq: 1}).WithAccountNumber(5)
+	factory = Factory{}.WithAccountRetriever(client.MockAccountRetriever{ReturnAccNum: 10, ReturnAccSeq: 1}).WithAccountNumber(5)
 	output, err = factory.Prepare(clientCtx.WithFrom("foo"))
 	require.NoError(t, err)
 	require.NotEqual(t, output, factory)
 	require.Equal(t, output.AccountNumber(), uint64(5))
 	require.Equal(t, output.Sequence(), uint64(1))
 
-	factory = tx.Factory{}.WithAccountRetriever(client.MockAccountRetriever{ReturnAccNum: 10, ReturnAccSeq: 1})
+	factory = Factory{}.WithAccountRetriever(client.MockAccountRetriever{ReturnAccNum: 10, ReturnAccSeq: 1})
 	output, err = factory.Prepare(clientCtx.WithFrom("foo"))
 	require.NoError(t, err)
 	require.NotEqual(t, output, factory)
 	require.Equal(t, output.AccountNumber(), uint64(10))
 	require.Equal(t, output.Sequence(), uint64(1))
 }
+
+func TestFactory_getSimPKType(t *testing.T) {
+	// setup keyring
+	registry := codectypes.NewInterfaceRegistry()
+	cryptocodec.RegisterInterfaces(registry)
+	k := keyring.NewInMemory(codec.NewProtoCodec(registry))
+
+	tests := []struct {
+		name     string
+		fromName string
+		genKey   func(fromName string, k keyring.Keyring) error
+		wantType types.PubKey
+	}{
+		{
+			name:     "simple key",
+			fromName: "testKey",
+			genKey: func(fromName string, k keyring.Keyring) error {
+				_, err := k.NewAccount(fromName, testdata.TestMnemonic, "", "", hd.Secp256k1)
+				return err
+			},
+			wantType: (*secp256k1.PubKey)(nil),
+		},
+		{
+			name:     "multisig key",
+			fromName: "multiKey",
+			genKey: func(fromName string, k keyring.Keyring) error {
+				pk := multisig.NewLegacyAminoPubKey(1, []types.PubKey{&multisig.LegacyAminoPubKey{}})
+				_, err := k.SaveMultisig(fromName, pk)
+				return err
+			},
+			wantType: (*multisig.LegacyAminoPubKey)(nil),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := tt.genKey(tt.fromName, k)
+			require.NoError(t, err)
+			f := Factory{
+				keybase:            k,
+				fromName:           tt.fromName,
+				simulateAndExecute: true,
+			}
+			got, err := f.getSimPK()
+			require.NoError(t, err)
+			require.IsType(t, tt.wantType, got)
+		})
+	}
+}
+
+func TestFactory_getSimSignatureData(t *testing.T) {
+	tests := []struct {
+		name     string
+		pk       types.PubKey
+		wantType any
+	}{
+		{
+			name:     "simple pubkey",
+			pk:       &secp256k1.PubKey{},
+			wantType: (*signing.SingleSignatureData)(nil),
+		},
+		{
+			name:     "multisig pubkey",
+			pk:       &multisig.LegacyAminoPubKey{},
+			wantType: (*signing.MultiSignatureData)(nil),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := Factory{}.getSimSignatureData(tt.pk)
+			require.IsType(t, tt.wantType, got)
+		})
+	}
+}