Merge branch 'main' into julian/remove-auth-globalConfig

CHANGELOG.md

@@ -42,6 +42,7 @@ Every module contains its own CHANGELOG.md. Please refer to the module you are i
 
 ### Features
 
+* (runtime) [#19571](https://github.com/cosmos/cosmos-sdk/pull/19571) Implement `core/router.Service` it in runtime. This service is present in all modules (when using depinject).
 * (types) [#19164](https://github.com/cosmos/cosmos-sdk/pull/19164) Add a ValueCodec for the math.Uint type that can be used in collections maps.
 * (types) [#19281](https://github.com/cosmos/cosmos-sdk/pull/19281) Added a new method, `IsGT`, for `types.Coin`. This method is used to check if a `types.Coin` is greater than another `types.Coin`.
 * (client) [#18557](https://github.com/cosmos/cosmos-sdk/pull/18557) Add `--qrcode` flag to `keys show` command to support displaying keys address QR code.

Makefile

@@ -384,7 +384,7 @@ benchmark:
 ### Linting ###
 ###############################################################################
 
-golangci_version=v1.55.0
+golangci_version=v1.56.2
 
 #? setup-pre-commit: Set pre-commit git hook
 setup-pre-commit:

baseapp/abci.go

@@ -1251,14 +1251,19 @@ func (app *BaseApp) CreateQueryContext(height int64, prove bool) (sdk.Context, e
  ctx := sdk.NewContext(cacheMS, true, app.logger).
  WithMinGasPrices(app.minGasPrices).
  WithBlockHeight(height).
- WithGasMeter(storetypes.NewGasMeter(app.queryGasLimit)).WithBlockHeader(app.checkState.Context().BlockHeader())
+ WithGasMeter(storetypes.NewGasMeter(app.queryGasLimit)).
+ WithHeaderInfo(coreheader.Info{
+ ChainID: app.chainID,
+ Height: height,
+ }).
+ WithBlockHeader(app.checkState.Context().BlockHeader())
 
  if height != lastBlockHeight {
  rms, ok := app.cms.(*rootmulti.Store)
  if ok {
  cInfo, err := rms.GetCommitInfo(height)
  if cInfo != nil && err == nil {
- ctx = ctx.WithHeaderInfo(coreheader.Info{Time: cInfo.Timestamp})
+ ctx = ctx.WithHeaderInfo(coreheader.Info{Height: height, Time: cInfo.Timestamp})
  }
  }
  }

baseapp/abci_test.go

@@ -1804,7 +1804,10 @@ func TestABCI_PrepareProposal_VoteExtensions(t *testing.T) {
  // set up baseapp
  prepareOpt := func(bapp *baseapp.BaseApp) {
  bapp.SetPrepareProposal(func(ctx sdk.Context, req *abci.RequestPrepareProposal) (*abci.ResponsePrepareProposal, error) {
- err := baseapp.ValidateVoteExtensions(ctx, valStore, req.Height, bapp.ChainID(), req.LocalLastCommit)
+ ctx = ctx.WithBlockHeight(req.Height).WithChainID(bapp.ChainID())
+ _, info := extendedCommitToLastCommit(req.LocalLastCommit)
+ ctx = ctx.WithCometInfo(info)
+ err := baseapp.ValidateVoteExtensions(ctx, valStore, req.LocalLastCommit)
  if err != nil {
  return nil, err
  }
@@ -2111,7 +2114,10 @@ func TestBaseApp_VoteExtensions(t *testing.T) {
 
  app.SetPrepareProposal(func(ctx sdk.Context, req *abci.RequestPrepareProposal) (*abci.ResponsePrepareProposal, error) {
  txs := [][]byte{}
- if err := baseapp.ValidateVoteExtensions(ctx, valStore, req.Height, app.ChainID(), req.LocalLastCommit); err != nil {
+ ctx = ctx.WithBlockHeight(req.Height).WithChainID(app.ChainID())
+ _, info := extendedCommitToLastCommit(req.LocalLastCommit)
+ ctx = ctx.WithCometInfo(info)
+ if err := baseapp.ValidateVoteExtensions(ctx, valStore, req.LocalLastCommit); err != nil {
  return nil, err
  }
  // add all VE as txs (in a real scenario we would need to check signatures too)

baseapp/abci_utils.go

@@ -4,6 +4,7 @@ import (
  "bytes"
  "context"
  "fmt"
+ "slices"
 
  "github.com/cockroachdb/errors"
  abci "github.com/cometbft/cometbft/abci/types"
@@ -14,6 +15,8 @@ import (
  protoio "github.com/cosmos/gogoproto/io"
  "github.com/cosmos/gogoproto/proto"
 
+ "cosmossdk.io/core/comet"
+
  sdk "github.com/cosmos/cosmos-sdk/types"
  "github.com/cosmos/cosmos-sdk/types/mempool"
 )
@@ -40,11 +43,19 @@ type (
 func ValidateVoteExtensions(
  ctx sdk.Context,
  valStore ValidatorStore,
- currentHeight int64,
- chainID string,
  extCommit abci.ExtendedCommitInfo,
 ) error {
+ // Get values from context
  cp := ctx.ConsensusParams()
+ currentHeight := ctx.HeaderInfo().Height
+ chainID := ctx.HeaderInfo().ChainID
+ commitInfo := ctx.CometInfo().LastCommit
+
+ // Check that both extCommit + commit are ordered in accordance with vp/address.
+ if err := validateExtendedCommitAgainstLastCommit(extCommit, commitInfo); err != nil {
+ return err
+ }
+
  // Start checking vote extensions only **after** the vote extensions enable
  // height, because when `currentHeight == VoteExtensionsEnableHeight`
  // PrepareProposal doesn't get any vote extensions in its request.
@@ -65,7 +76,6 @@ func ValidateVoteExtensions(
  sumVP int64
  )
 
- cache := make(map[string]struct{})
  for _, vote := range extCommit.Votes {
  totalVP += vote.Validator.Power
 
@@ -90,12 +100,7 @@ func ValidateVoteExtensions(
  return fmt.Errorf("vote extensions enabled; received empty vote extension signature at height %d", currentHeight)
  }
 
- // Ensure that the validator has not already submitted a vote extension.
  valConsAddr := sdk.ConsAddress(vote.Validator.Address)
- if _, ok := cache[valConsAddr.String()]; ok {
- return fmt.Errorf("duplicate validator; validator %s has already submitted a vote extension", valConsAddr.String())
- }
- cache[valConsAddr.String()] = struct{}{}
 
  pubKeyProto, err := valStore.GetPubKeyByConsAddr(ctx, valConsAddr)
  if err != nil {
@@ -141,6 +146,51 @@ func ValidateVoteExtensions(
  return nil
 }
 
+// validateExtendedCommitAgainstLastCommit validates an ExtendedCommitInfo against a LastCommit. Specifically,
+// it checks that the ExtendedCommit + LastCommit (for the same height), are consistent with each other + that
+// they are ordered correctly (by voting power) in accordance with
+// [comet](https://github.com/cometbft/cometbft/blob/4ce0277b35f31985bbf2c25d3806a184a4510010/types/validator_set.go#L784).
+func validateExtendedCommitAgainstLastCommit(ec abci.ExtendedCommitInfo, lc comet.CommitInfo) error {
+ // check that the rounds are the same
+ if ec.Round != lc.Round {
+ return fmt.Errorf("extended commit round %d does not match last commit round %d", ec.Round, lc.Round)
+ }
+
+ // check that the # of votes are the same
+ if len(ec.Votes) != len(lc.Votes) {
+ return fmt.Errorf("extended commit votes length %d does not match last commit votes length %d", len(ec.Votes), len(lc.Votes))
+ }
+
+ // check sort order of extended commit votes
+ if !slices.IsSortedFunc(ec.Votes, func(vote1, vote2 abci.ExtendedVoteInfo) int {
+ if vote1.Validator.Power == vote2.Validator.Power {
+ return bytes.Compare(vote1.Validator.Address, vote2.Validator.Address) // addresses sorted in ascending order (used to break vp conflicts)
+ }
+ return -int(vote1.Validator.Power - vote2.Validator.Power) // vp sorted in descending order
+ }) {
+ return fmt.Errorf("extended commit votes are not sorted by voting power")
+ }
+
+ addressCache := make(map[string]struct{}, len(ec.Votes))
+ // check consistency between LastCommit and ExtendedCommit
+ for i, vote := range ec.Votes {
+ // cache addresses to check for duplicates
+ if _, ok := addressCache[string(vote.Validator.Address)]; ok {
+ return fmt.Errorf("extended commit vote address %X is duplicated", vote.Validator.Address)
+ }
+ addressCache[string(vote.Validator.Address)] = struct{}{}
+
+ if !bytes.Equal(vote.Validator.Address, lc.Votes[i].Validator.Address) {
+ return fmt.Errorf("extended commit vote address %X does not match last commit vote address %X", vote.Validator.Address, lc.Votes[i].Validator.Address)
+ }
+ if vote.Validator.Power != lc.Votes[i].Validator.Power {
+ return fmt.Errorf("extended commit vote power %d does not match last commit vote power %d", vote.Validator.Power, lc.Votes[i].Validator.Power)
+ }
+ }
+
+ return nil
+}
+
 type (
  // ProposalTxVerifier defines the interface that is implemented by BaseApp,
  // that any custom ABCI PrepareProposal and ProcessProposal handler can use