From ba09911eb69a565948c9177e887f3a3351318ec0 Mon Sep 17 00:00:00 2001 From: Julien Robert Date: Wed, 6 Jul 2022 18:42:48 +0200 Subject: [PATCH 01/37] docs: clarify differences and usage of `submit-proposal` and `submit-legacy-proposal` for gov (#12410) --- CHANGELOG.md | 2 +- x/gov/spec/01_concepts.md | 4 ++-- x/gov/spec/02_state.md | 25 +++++++++++++++++-------- x/gov/spec/07_client.md | 6 +++--- 4 files changed, 23 insertions(+), 14 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 295da4b27d63..b4374fcc03fc 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -229,7 +229,7 @@ empty coins slice before it is used to create `banktype.MsgSend`. * [\#9594](https://github.com/cosmos/cosmos-sdk/pull/9594) Remove legacy REST API. Please see the [REST Endpoints Migration guide](https://docs.cosmos.network/master/migrations/rest.html) to migrate to the new REST endpoints. * [\#9995](https://github.com/cosmos/cosmos-sdk/pull/9995) Increased gas cost for creating proposals. * [\#11029](https://github.com/cosmos/cosmos-sdk/pull/11029) The deprecated Vote Option field is removed in gov v1beta2 and nil in v1beta1. Use Options instead. -* [\#11013](https://github.com/cosmos/cosmos-sdk/pull/) The `tx gov submit-proposal` command has changed syntax to support the new Msg-based gov proposals. To access the old CLI command, please use `tx gov submit-legacy-proposal`. +* [\#11013](https://github.com/cosmos/cosmos-sdk/pull/11013) The `tx gov submit-proposal` command has changed syntax to support the new Msg-based gov proposals. To access the old CLI command, please use `tx gov submit-legacy-proposal`. * [\#11170](https://github.com/cosmos/cosmos-sdk/issues/11170) Fixes issue related to grpc-gateway of supply by ibc-denom. ### CLI Breaking Changes diff --git a/x/gov/spec/01_concepts.md b/x/gov/spec/01_concepts.md index e1a36f90094e..61843453d679 100644 --- a/x/gov/spec/01_concepts.md +++ b/x/gov/spec/01_concepts.md @@ -177,7 +177,7 @@ Later, we may add permissioned keys that could only sign txs from certain module If proposals are of type `SoftwareUpgradeProposal`, then nodes need to upgrade their software to the new version that was voted. This process is divided into -two steps. +two steps: ### Signal @@ -200,4 +200,4 @@ Once a block contains more than 2/3rd _precommits_ where a common nodes, non-validating full nodes and light-nodes) are expected to switch to the new version of the software. -_Note: Not clear how the flip is handled programmatically._ +Validators and full nodes can use an automation tool, such as [Cosmovisor](https://github.com/cosmos/cosmos-sdk/blob/main/cosmovisor/README.md), for automatically switching version of the chain. diff --git a/x/gov/spec/02_state.md b/x/gov/spec/02_state.md index 78af0fe5615e..66514ec2c54c 100644 --- a/x/gov/spec/02_state.md +++ b/x/gov/spec/02_state.md @@ -16,11 +16,11 @@ unique id and contains a series of timestamps: `submit_time`, `deposit_end_time` A proposal will generally require more than just a set of messages to explain its purpose but need some greater justification and allow a means for interested participants -to discuss and debate the proposal. In most cases, it is encouraged to have an off-chain -system that supports the on-chain governance process. To accommodate for this, a -proposal contains a special `metadata` field, an array of bytes, which can be used to -add context to the proposal. The `metadata` field allows custom use for networks, however, -it is expected that the field contains a URL or some form of CID using a system such as +to discuss and debate the proposal. +In most cases, **it is encouraged to have an off-chain system that supports the on-chain governance process**. +To accommodate for this, a proposal contains a special **`metadata`** field, an array of bytes, +which can be used to add context to the proposal. The `metadata` field allows custom use for networks, +however, it is expected that the field contains a URL or some form of CID using a system such as [IPFS](https://docs.ipfs.io/concepts/content-addressing/). To support the case of interoperability across networks, the SDK recommends that the `metadata` represents the following `JSON` template: @@ -37,7 +37,7 @@ the following `JSON` template: This makes it far easier for clients to support multiple networks. The metadata has a maximum length that is chosen by the app developer, and -passed into the gov keeper as a config. +passed into the gov keeper as a config. The default maximum length in the SDK is 255 characters. ### Writing a module that uses governance @@ -119,8 +119,7 @@ This type is used in a temp map when tallying ## Stores -_Stores are KVStores in the multi-store. The key to find the store is the first -parameter in the list_` +_Note: Stores are KVStores in the multi-store. The key to find the store is the first parameter in the list_ We will use one KVStore `Governance` to store two mappings: @@ -206,3 +205,13 @@ And the pseudocode for the `ProposalProcessingQueue`: store(Governance, , proposal) ``` + +## Legacy Proposal + +A legacy proposal is the old implementation of governance proposal. +Contrary to proposal that can contain any messages, a legacy proposal allows to submit a set of pre-defined proposals. +These proposal are defined by their types. + +While proposals should use the new implementation of the governance proposal, we need still to use legacy proposal in order to submit a `software-upgrade` and a `cancel-software-upgrade` proposal. + +More information on how to submit proposals in the [client section](07_client.md). diff --git a/x/gov/spec/07_client.md b/x/gov/spec/07_client.md index 0532ad907c09..00aa57e57859 100644 --- a/x/gov/spec/07_client.md +++ b/x/gov/spec/07_client.md @@ -361,14 +361,14 @@ Example: simd tx gov submit-proposal /path/to/proposal.json --from cosmos1.. ``` -where proposal.json contains: +where `proposal.json` contains: -```bash +```json { "messages": [ { "@type": "/cosmos.bank.v1beta1.MsgSend", - "from_address": "cosmos1...", + "from_address": "cosmos1...", // The gov module module address "to_address": "cosmos1...", "amount":[{"denom": "stake","amount": "10"}] } From e7f78b4480005275ab5a4ed1487ca2eb7cb36849 Mon Sep 17 00:00:00 2001 From: Daniel Wedul Date: Wed, 6 Jul 2022 13:35:39 -0600 Subject: [PATCH 02/37] feat(cosmovisor): Create Cosmovisor init command. (#12464) ## Description Closes: #12456 Creates an `init` command in `cosmovisor` that initializes the `DAEMON_HOME` directory with the initial executable and current link. --- ### Author Checklist *All items are required. Please add a note to the item if the item is not applicable and please add links to any relevant follow up issues.* I have... - [x] included the correct [type prefix](https://github.com/commitizen/conventional-commit-types/blob/v3.0.0/index.json) in the PR title - [ ] ~~added `!` to the type prefix if API or client breaking change~~ _N/A_ - [x] targeted the correct branch (see [PR Targeting](https://github.com/cosmos/cosmos-sdk/blob/main/CONTRIBUTING.md#pr-targeting)) - [x] provided a link to the relevant issue or specification - [ ] ~~followed the guidelines for [building modules](https://github.com/cosmos/cosmos-sdk/blob/main/docs/building-modules)~~ _N/A_ - [x] included the necessary unit and integration [tests](https://github.com/cosmos/cosmos-sdk/blob/main/CONTRIBUTING.md#testing) - [x] added a changelog entry to `CHANGELOG.md` - [x] included comments for [documenting Go code](https://blog.golang.org/godoc) - [x] updated the relevant documentation or specification - [x] reviewed "Files changed" and left comments if necessary - [ ] confirmed all CI checks have passed ### Reviewers Checklist *All items are required. Please add a note if the item is not applicable and please add your handle next to the items reviewed if you only reviewed selected items.* I have... - [ ] confirmed the correct [type prefix](https://github.com/commitizen/conventional-commit-types/blob/v3.0.0/index.json) in the PR title - [ ] confirmed `!` in the type prefix if API or client breaking change - [ ] confirmed all author checklist items have been addressed - [ ] reviewed state machine logic - [ ] reviewed API design and naming - [ ] reviewed documentation is accurate - [ ] reviewed tests and test coverage - [ ] manually tested (if applicable) --- cosmovisor/CHANGELOG.md | 1 + cosmovisor/README.md | 37 +- cosmovisor/cmd/cosmovisor/init.go | 136 ++++++ cosmovisor/cmd/cosmovisor/init_test.go | 554 +++++++++++++++++++++++++ 4 files changed, 726 insertions(+), 2 deletions(-) create mode 100644 cosmovisor/cmd/cosmovisor/init.go create mode 100644 cosmovisor/cmd/cosmovisor/init_test.go diff --git a/cosmovisor/CHANGELOG.md b/cosmovisor/CHANGELOG.md index 14eddf401b51..fc38e7634b43 100644 --- a/cosmovisor/CHANGELOG.md +++ b/cosmovisor/CHANGELOG.md @@ -39,6 +39,7 @@ Ref: https://keepachangelog.com/en/1.0.0/ ### Features +* [\#12464](https://github.com/cosmos/cosmos-sdk/pull/12464) Create the `cosmovisor init` command. * [\#12188](https://github.com/cosmos/cosmos-sdk/pull/12188) Add a `DAEMON_RESTART_DELAY` for allowing a node operator to define a delay between the node halt (for upgrade) and backup. * [\#11823](https://github.com/cosmos/cosmos-sdk/pull/11823) Refactor `cosmovisor` CLI to use `cobra`. * [\#11731](https://github.com/cosmos/cosmos-sdk/pull/11731) `cosmovisor version -o json` returns the cosmovisor version and the result of `simd --output json --long` in one JSON object. diff --git a/cosmovisor/README.md b/cosmovisor/README.md index cb4258225145..12b5e054e3b3 100644 --- a/cosmovisor/README.md +++ b/cosmovisor/README.md @@ -2,6 +2,22 @@ `cosmovisor` is a small process manager for Cosmos SDK application binaries that monitors the governance module for incoming chain upgrade proposals. If it sees a proposal that gets approved, `cosmovisor` can automatically download the new binary, stop the current binary, switch from the old binary to the new one, and finally restart the node with the new binary. + + - [Design](#design) + - [Contributing](#contributing) + - [Setup](#setup) + - [Installation](#installation) + - [Command Line Arguments And Environment Variables](#command-line-arguments-and-environment-variables) + - [Folder Layout](#folder-layout) + - [Usage](#usage) + - [Initialization](#initialization) + - [Detecting Upgrades](#detecting-upgrades) + - [Auto-Download](#auto-download) + - [Example: SimApp Upgrade](#example-simapp-upgrade) + - [Chain Setup](#chain-setup) + + + ## Design Cosmovisor is designed to be used as a wrapper for a `Cosmos SDK` app: @@ -115,8 +131,10 @@ The system administrator is responsible for: * installing the `cosmovisor` binary * configuring the host's init system (e.g. `systemd`, `launchd`, etc.) * appropriately setting the environmental variables -* manually installing the `genesis` folder -* manually installing the `upgrades/` folders +* creating the `/cosmovisor` directory +* creating the `/cosmovisor/genesis/bin` folder +* creating the `/cosmovisor/upgrades//bin` folders +* placing the different versions of the `` executable in the appropriate `bin` folders. `cosmovisor` will set the `current` link to point to `genesis` at first start (i.e. when no `current` link exists) and then handle switching binaries at the correct points in time so that the system administrator can prepare days in advance and relax at upgrade time. @@ -124,6 +142,21 @@ In order to support downloadable binaries, a tarball for each upgrade binary wil The `DAEMON` specific code and operations (e.g. tendermint config, the application db, syncing blocks, etc.) all work as expected. The application binaries' directives such as command-line flags and environment variables also work as expected. +### Initialization + +The `cosmovisor init ` command creates the folder structure required for using cosmovisor. + +It does the following: + +* creates the `/cosmovisor` folder if it doesn't yet exist +* creates the `/cosmovisor/genesis/bin` folder if it doesn't yet exist +* copies the provided executable file to `/cosmovisor/genesis/bin/` +* creates the `current` link, pointing to the `genesis` folder + +It uses the `DAEMON_HOME` and `DAEMON_NAME` environment variables for folder location and executable name. + +The `cosmovisor init` command is specifically for initializing cosmovisor, and should not be confused with a chain's `init` command (e.g. `cosmovisor run init`). + ### Detecting Upgrades `cosmovisor` is polling the `$DAEMON_HOME/data/upgrade-info.json` file for new upgrade instructions. The file is created by the x/upgrade module in `BeginBlocker` when an upgrade is detected and the blockchain reaches the upgrade height. diff --git a/cosmovisor/cmd/cosmovisor/init.go b/cosmovisor/cmd/cosmovisor/init.go new file mode 100644 index 000000000000..db06caa02297 --- /dev/null +++ b/cosmovisor/cmd/cosmovisor/init.go @@ -0,0 +1,136 @@ +package main + +import ( + "errors" + "fmt" + "io" + "os" + "path/filepath" + + "github.com/rs/zerolog" + "github.com/spf13/cobra" + + "github.com/cosmos/cosmos-sdk/cosmovisor" + cverrors "github.com/cosmos/cosmos-sdk/cosmovisor/errors" +) + +func init() { + rootCmd.AddCommand(initCmd) +} + +var initCmd = &cobra.Command{ + Use: "init ", + Short: "Initializes a cosmovisor daemon home directory.", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + logger := cmd.Context().Value(cosmovisor.LoggerKey).(*zerolog.Logger) + + return InitializeCosmovisor(logger, args) + }, +} + +// InitializeCosmovisor initializes the cosmovisor directories, current link, and initial executable. +func InitializeCosmovisor(logger *zerolog.Logger, args []string) error { + if len(args) < 1 || len(args[0]) == 0 { + return errors.New("no provided") + } + pathToExe := args[0] + switch exeInfo, err := os.Stat(pathToExe); { + case os.IsNotExist(err): + return fmt.Errorf("executable file not found: %w", err) + case err != nil: + return fmt.Errorf("could not stat executable: %w", err) + case exeInfo.IsDir(): + return errors.New("invalid path to executable: must not be a directory") + } + cfg, err := getConfigForInitCmd() + if err != nil { + return err + } + + logger.Info().Msg("checking on the genesis/bin directory") + genBinExe := cfg.GenesisBin() + genBinDir, _ := filepath.Split(genBinExe) + genBinDir = filepath.Clean(genBinDir) + switch genBinDirInfo, genBinDirErr := os.Stat(genBinDir); { + case os.IsNotExist(genBinDirErr): + logger.Info().Msgf("creating directory (and any parents): %q", genBinDir) + mkdirErr := os.MkdirAll(genBinDir, 0o755) + if mkdirErr != nil { + return mkdirErr + } + case genBinDirErr != nil: + return fmt.Errorf("error getting info on genesis/bin directory: %w", genBinDirErr) + case !genBinDirInfo.IsDir(): + return fmt.Errorf("the path %q already exists but is not a directory", genBinDir) + default: + logger.Info().Msgf("the %q directory already exists", genBinDir) + } + + logger.Info().Msg("checking on the genesis/bin executable") + if _, err = os.Stat(genBinExe); os.IsNotExist(err) { + logger.Info().Msgf("copying executable into place: %q", genBinExe) + if cpErr := copyFile(pathToExe, genBinExe); cpErr != nil { + return cpErr + } + } else { + logger.Info().Msgf("the %q file already exists", genBinExe) + } + logger.Info().Msgf("making sure %q is executable", genBinExe) + if err = cosmovisor.MarkExecutable(genBinExe); err != nil { + return err + } + if err = cosmovisor.EnsureBinary(genBinExe); err != nil { + return err + } + + logger.Info().Msg("checking on the current symlink and creating it if needed") + cur, curErr := cfg.CurrentBin() + if curErr != nil { + return curErr + } + logger.Info().Msgf("the current symlink points to: %q", cur) + + return nil +} + +// getConfigForInitCmd gets just the configuration elements needed to initialize cosmovisor. +func getConfigForInitCmd() (*cosmovisor.Config, error) { + var errs []error + // Note: Not using GetConfigFromEnv here because that checks that the directories already exist. + // We also don't care about the rest of the configuration stuff in here. + cfg := &cosmovisor.Config{ + Home: os.Getenv(cosmovisor.EnvHome), + Name: os.Getenv(cosmovisor.EnvName), + } + if len(cfg.Name) == 0 { + errs = append(errs, fmt.Errorf("%s is not set", cosmovisor.EnvName)) + } + switch { + case len(cfg.Home) == 0: + errs = append(errs, fmt.Errorf("%s is not set", cosmovisor.EnvHome)) + case !filepath.IsAbs(cfg.Home): + errs = append(errs, fmt.Errorf("%s must be an absolute path", cosmovisor.EnvHome)) + } + if len(errs) > 0 { + return nil, cverrors.FlattenErrors(errs...) + } + return cfg, nil +} + +// copyFile copies the file at the given source to the given destination. +func copyFile(source, destination string) error { + // assume we already know that src exists and is a regular file. + src, err := os.Open(source) + if err != nil { + return err + } + defer src.Close() + dst, err := os.Create(destination) + if err != nil { + return err + } + defer dst.Close() + _, err = io.Copy(dst, src) + return err +} diff --git a/cosmovisor/cmd/cosmovisor/init_test.go b/cosmovisor/cmd/cosmovisor/init_test.go new file mode 100644 index 000000000000..472936eaac4b --- /dev/null +++ b/cosmovisor/cmd/cosmovisor/init_test.go @@ -0,0 +1,554 @@ +package main + +import ( + "bytes" + "fmt" + "io" + "os" + "path/filepath" + "testing" + "time" + + "github.com/rs/zerolog" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "github.com/stretchr/testify/suite" + + "github.com/cosmos/cosmos-sdk/cosmovisor" +) + +type InitTestSuite struct { + suite.Suite +} + +func TestInitTestSuite(t *testing.T) { + suite.Run(t, new(InitTestSuite)) +} + +// cosmovisorInitEnv are some string values of environment variables used to configure Cosmovisor, and used by the init command. +type cosmovisorInitEnv struct { + Home string + Name string +} + +// ToMap creates a map of the cosmovisorInitEnv where the keys are the env var names. +func (c cosmovisorInitEnv) ToMap() map[string]string { + return map[string]string{ + cosmovisor.EnvHome: c.Home, + cosmovisor.EnvName: c.Name, + } +} + +// Set sets the field in this cosmovisorInitEnv corresponding to the provided envVar to the given envVal. +func (c *cosmovisorInitEnv) Set(envVar, envVal string) { + switch envVar { + case cosmovisor.EnvHome: + c.Home = envVal + case cosmovisor.EnvName: + c.Name = envVal + default: + panic(fmt.Errorf("Unknown environment variable [%s]. Cannot set field to [%s]. ", envVar, envVal)) + } +} + +// clearEnv clears environment variables and returns what they were. +// Designed to be used like this: +// initialEnv := clearEnv() +// defer setEnv(nil, initialEnv) +func (s *InitTestSuite) clearEnv() *cosmovisorInitEnv { + s.T().Logf("Clearing environment variables.") + rv := cosmovisorInitEnv{} + for envVar := range rv.ToMap() { + rv.Set(envVar, os.Getenv(envVar)) + s.Require().NoError(os.Unsetenv(envVar)) + } + return &rv +} + +// setEnv sets environment variables to the values provided. +// If t is not nil, and there's a problem, the test will fail immediately. +// If t is nil, problems will just be logged using s.T(). +func (s *InitTestSuite) setEnv(t *testing.T, env *cosmovisorInitEnv) { + if t == nil { + s.T().Logf("Restoring environment variables.") + } + for envVar, envVal := range env.ToMap() { + var err error + var msg string + if len(envVal) != 0 { + err = os.Setenv(envVar, envVal) + msg = fmt.Sprintf("setting %s to %s", envVar, envVal) + } else { + err = os.Unsetenv(envVar) + msg = fmt.Sprintf("unsetting %s", envVar) + } + switch { + case t != nil: + require.NoError(t, err, msg) + case err != nil: + s.T().Logf("error %s: %v", msg, err) + default: + s.T().Logf("done %s", msg) + } + } +} + +var _ io.Reader = BufferedPipe{} +var _ io.Writer = BufferedPipe{} + +// BufferedPipe contains a connected read/write pair of files (a pipe), +// and a buffer of what goes through it that is populated in the background. +type BufferedPipe struct { + // Name is a string to help humans identify this BufferedPipe. + Name string + // Reader is the reader end of the pipe. + Reader *os.File + // Writer is the writer end of the pipe. + Writer *os.File + // BufferReader is the reader used by this BufferedPipe while buffering. + // If this BufferedPipe is not replicating to anything, it will be the same as the Reader. + // Otherwise, it will be a reader encapsulating all desired replication. + BufferReader io.Reader + // Error is the last error encountered by this BufferedPipe. + Error error + + // buffer is the channel used to communicate buffer contents. + buffer chan []byte + // stated is true if this BufferedPipe has been started. + started bool +} + +// NewBufferedPipe creates a new BufferedPipe with the given name. +// Files must be closed once you are done with them (e.g. with .Close()). +// Once ready, buffering must be started using .Start(). See also StartNewBufferedPipe. +func NewBufferedPipe(name string, replicateTo ...io.Writer) (BufferedPipe, error) { + p := BufferedPipe{Name: name} + p.Reader, p.Writer, p.Error = os.Pipe() + if p.Error != nil { + return p, p.Error + } + p.BufferReader = p.Reader + p.AddReplicationTo(replicateTo...) + return p, nil +} + +// StartNewBufferedPipe creates a new BufferedPipe and starts it. +// +// This is functionally equivalent to: +// p, _ := NewBufferedPipe(name, replicateTo...) +// p.Start() +func StartNewBufferedPipe(name string, replicateTo ...io.Writer) (BufferedPipe, error) { + p, err := NewBufferedPipe(name, replicateTo...) + if err != nil { + return p, err + } + p.Start() + return p, nil +} + +// AddReplicationTo adds replication of this buffered pipe to the provided writers. +// +// Panics if this BufferedPipe is already started. +func (p *BufferedPipe) AddReplicationTo(writers ...io.Writer) { + p.panicIfStarted("cannot add further replication") + for _, writer := range writers { + p.BufferReader = io.TeeReader(p.BufferReader, writer) + } +} + +// Start initiates buffering in a background process. +// +// Panics if this BufferedPipe is already started. +func (p *BufferedPipe) Start() { + p.panicIfStarted("cannot restart") + p.buffer = make(chan []byte) + go func() { + var b bytes.Buffer + if _, p.Error = io.Copy(&b, p.BufferReader); p.Error != nil { + b.WriteString("buffer error: " + p.Error.Error()) + } + p.buffer <- b.Bytes() + }() + p.started = true +} + +// IsStarted returns true if this BufferedPipe has already been started. +func (p *BufferedPipe) IsStarted() bool { + return p.started +} + +// IsBuffering returns true if this BufferedPipe has started buffering and has not yet been collected. +func (p *BufferedPipe) IsBuffering() bool { + return p.buffer != nil +} + +// Collect closes this pipe's writer then blocks, returning with the final buffer contents once available. +// If Collect() has previously been called on this BufferedPipe, an empty byte slice is returned. +// +// Panics if this BufferedPipe has not been started. +func (p *BufferedPipe) Collect() []byte { + if !p.started { + panic("buffered pipe " + p.Name + " has not been started: cannot collect") + } + _ = p.Writer.Close() + if p.buffer == nil { + return []byte{} + } + rv := <-p.buffer + p.buffer = nil + return rv +} + +// Read implements the io.Reader interface on this BufferedPipe. +func (p BufferedPipe) Read(bz []byte) (n int, err error) { + return p.Reader.Read(bz) +} + +// Write implements the io.Writer interface on this BufferedPipe. +func (p BufferedPipe) Write(bz []byte) (n int, err error) { + return p.Writer.Write(bz) +} + +// Close makes sure the files in this BufferedPipe are closed. +func (p *BufferedPipe) Close() { + _ = p.Reader.Close() + _ = p.Writer.Close() +} + +// panicIfStarted panics if this BufferedPipe has been started. +func (p *BufferedPipe) panicIfStarted(msg string) { + if p.started { + panic("buffered pipe " + p.Name + " already started: " + msg) + } +} + +// NewCapturingLogger creates a buffered stdout pipe, and a logger that uses it. +func (s *InitTestSuite) NewCapturingLogger() (*BufferedPipe, *zerolog.Logger) { + bufferedStdOut, err := StartNewBufferedPipe("stdout", os.Stdout) + s.Require().NoError(err, "creating stdout buffered pipe") + output := zerolog.ConsoleWriter{Out: bufferedStdOut, TimeFormat: time.RFC3339Nano} + logger := zerolog.New(output).With().Str("module", "cosmovisor").Timestamp().Logger() + return &bufferedStdOut, &logger +} + +// CreateHelloWorld creates a shell script that outputs HELLO WORLD. +// It will have the provided filemode and be in a freshly made temp directory. +// The returned string is the full path to the new file. +func (s *InitTestSuite) CreateHelloWorld(filemode os.FileMode) string { + tmpDir := s.T().TempDir() + tmpExe := filepath.Join(tmpDir, "hello-world.sh") + tmpExeBz := []byte(`#!/bin/sh +echo 'HELLO WORLD' +`) + s.Require().NoError(os.WriteFile(tmpExe, tmpExeBz, filemode)) + return tmpExe +} + +func (s *InitTestSuite) TestInitializeCosmovisorNegativeValidation() { + initEnv := s.clearEnv() + defer s.setEnv(nil, initEnv) + + tmpExe := s.CreateHelloWorld(0o755) + + tmpDir := s.T().TempDir() + + tests := []struct { + name string + env cosmovisorInitEnv + args []string + inErr []string + }{ + { + name: "no args", + env: cosmovisorInitEnv{Home: "/example", Name: "foo"}, + args: []string{}, + inErr: []string{"no provided"}, + }, + { + name: "one empty arg", + env: cosmovisorInitEnv{Home: "/example", Name: "foo"}, + args: []string{""}, + inErr: []string{"no provided"}, + }, + { + name: "exe not found", + env: cosmovisorInitEnv{Home: "/example", Name: "foo"}, + args: []string{filepath.Join(tmpDir, "not-gonna-find-me")}, + inErr: []string{"executable file not found", "not-gonna-find-me"}, + }, + { + name: "exe is a dir", + env: cosmovisorInitEnv{Home: "/example", Name: "foo"}, + args: []string{tmpDir}, + inErr: []string{"invalid path to executable: must not be a directory"}, + }, + { + name: "no name", + env: cosmovisorInitEnv{Home: "/example", Name: ""}, + args: []string{tmpExe}, + inErr: []string{cosmovisor.EnvName + " is not set"}, + }, + { + name: "no home", + env: cosmovisorInitEnv{Home: "", Name: "foo"}, + args: []string{tmpExe}, + inErr: []string{cosmovisor.EnvHome + " is not set"}, + }, + { + name: "home is relative", + env: cosmovisorInitEnv{Home: "./home", Name: "foo"}, + args: []string{tmpExe}, + inErr: []string{cosmovisor.EnvHome + " must be an absolute path"}, + }, + { + name: "no name and no home", + env: cosmovisorInitEnv{Home: "", Name: ""}, + args: []string{tmpExe}, + inErr: []string{cosmovisor.EnvName + " is not set", cosmovisor.EnvHome + " is not set"}, + }, + } + + for _, tc := range tests { + s.T().Run(tc.name, func(t *testing.T) { + s.setEnv(t, &tc.env) + buffer, logger := s.NewCapturingLogger() + err := InitializeCosmovisor(logger, tc.args) + require.Error(t, err) + for _, exp := range tc.inErr { + require.ErrorContains(t, err, exp) + } + // And make sure there wasn't any log output. + // Log output indicates that work is being done despite validation errors. + outputBz := buffer.Collect() + outputStr := string(outputBz) + require.Equal(t, "", outputStr, "log output") + }) + } +} + +func (s *InitTestSuite) TestInitializeCosmovisorInvalidExisting() { + initEnv := s.clearEnv() + defer s.setEnv(nil, initEnv) + + hwExe := s.CreateHelloWorld(0o755) + + s.T().Run("genesis bin is not a directory", func(t *testing.T) { + testDir := t.TempDir() + env := &cosmovisorInitEnv{ + Home: filepath.Join(testDir, "home"), + Name: "pear", + } + genDir := filepath.Join(env.Home, "cosmovisor", "genesis") + genBin := filepath.Join(genDir, "bin") + require.NoError(t, os.MkdirAll(genDir, 0o755), "creating genesis directory") + require.NoError(t, copyFile(hwExe, genBin), "copying exe to genesis/bin") + + s.setEnv(t, env) + logger := zerolog.Nop() + expErr := fmt.Sprintf("the path %q already exists but is not a directory", genBin) + err := InitializeCosmovisor(&logger, []string{hwExe}) + require.EqualError(t, err, expErr, "invalid path to executable: must not be a directory", "calling InitializeCosmovisor") + }) + + s.T().Run("the EnsureBinary test fails", func(t *testing.T) { + testDir := t.TempDir() + env := &cosmovisorInitEnv{ + Home: filepath.Join(testDir, "home"), + Name: "grapes", + } + // Create the genesis bin executable path fully as a directory (instead of a file). + // That should get through all the other stuff, but error when EnsureBinary is called. + genBinExe := filepath.Join(env.Home, "cosmovisor", "genesis", "bin", env.Name) + require.NoError(t, os.MkdirAll(genBinExe, 0o755)) + expErr := fmt.Sprintf("%s is not a regular file", env.Name) + // Check the log messages just to make sure it's erroring where expecting. + expInLog := []string{ + "checking on the genesis/bin directory", + "checking on the genesis/bin executable", + fmt.Sprintf("the %q file already exists", genBinExe), + fmt.Sprintf("making sure %q is executable", genBinExe), + } + expNotInLog := []string{ + "checking on the current symlink and creating it if needed", + "the current symlink points to", + } + + s.setEnv(t, env) + buffer, logger := s.NewCapturingLogger() + logger.Info().Msgf("Calling InitializeCosmovisor: %s", t.Name()) + err := InitializeCosmovisor(logger, []string{hwExe}) + require.EqualError(t, err, expErr, "calling InitializeCosmovisor") + bufferBz := buffer.Collect() + bufferStr := string(bufferBz) + for _, exp := range expInLog { + assert.Contains(t, bufferStr, exp, "expected log statement") + } + for _, notExp := range expNotInLog { + assert.NotContains(t, bufferStr, notExp, "unexpected log statement") + } + }) + + s.T().Run("current already exists as a file", func(t *testing.T) { + testDir := t.TempDir() + env := &cosmovisorInitEnv{ + Home: filepath.Join(testDir, "home"), + Name: "orange", + } + rootDir := filepath.Join(env.Home, "cosmovisor") + require.NoError(t, os.MkdirAll(rootDir, 0o755)) + curLn := filepath.Join(rootDir, "current") + genDir := filepath.Join(rootDir, "genesis") + require.NoError(t, copyFile(hwExe, curLn)) + expErr := fmt.Sprintf("symlink %s %s: file exists", genDir, curLn) + + s.setEnv(t, env) + buffer, logger := s.NewCapturingLogger() + logger.Info().Msgf("Calling InitializeCosmovisor: %s", t.Name()) + err := InitializeCosmovisor(logger, []string{hwExe}) + require.EqualError(t, err, expErr, "calling InitializeCosmovisor") + bufferBz := buffer.Collect() + bufferStr := string(bufferBz) + assert.Contains(t, bufferStr, "checking on the current symlink and creating it if needed") + }) + + // Failure cases not tested: + // Cannot create genesis bin directory + // I had a test for this that created the `genesis` directory with permissions 0o555. + // I also tried it where it would create the directory at the root of the file system. + // In both cases, the test worked as expected locally, but not on the github runners. So it was removed. + // Given executable is not readable + // I had a test for this that created the executable with permissions 0o311. + // The test worked as expected locally, but not on the github runners. So it was removed. + // Cannot get info on the genesis bin directory. + // Not sure how to create a thing that will return + // an error other than a NotExists error when stat is called on it. + // Cannot write to genesis bin dir + // I had a test for this that created the bin dir with permissions 0o555. + // The test worked as expected locally, but not on the github runners. So it was removed. + // Cannot make the copied file executable. + // Probably need another user for this. + // Create the genesis bin file first, using the other user, and set permissions to 600. +} + +func (s *InitTestSuite) TestInitializeCosmovisorValid() { + initEnv := s.clearEnv() + defer s.setEnv(nil, initEnv) + + hwNonExe := s.CreateHelloWorld(0o644) + hwExe := s.CreateHelloWorld(0o755) + + s.T().Run("starting with blank slate", func(t *testing.T) { + testDir := s.T().TempDir() + env := &cosmovisorInitEnv{ + Home: filepath.Join(testDir, "home"), + Name: "blank", + } + curLn := filepath.Join(env.Home, "cosmovisor", "current") + genBinDir := filepath.Join(env.Home, "cosmovisor", "genesis", "bin") + genBinExe := filepath.Join(genBinDir, env.Name) + expInLog := []string{ + "checking on the genesis/bin directory", + fmt.Sprintf("creating directory (and any parents): %q", genBinDir), + "checking on the genesis/bin executable", + fmt.Sprintf("copying executable into place: %q", genBinExe), + fmt.Sprintf("making sure %q is executable", genBinExe), + "checking on the current symlink and creating it if needed", + fmt.Sprintf("the current symlink points to: %q", genBinExe), + } + + s.setEnv(s.T(), env) + buffer, logger := s.NewCapturingLogger() + logger.Info().Msgf("Calling InitializeCosmovisor: %s", t.Name()) + err := InitializeCosmovisor(logger, []string{hwNonExe}) + require.NoError(t, err, "calling InitializeCosmovisor") + + _, err = os.Stat(genBinDir) + assert.NoErrorf(t, err, "statting the genesis bin dir: %q", genBinDir) + _, err = os.Stat(curLn) + assert.NoError(t, err, "statting the current link: %q", curLn) + exeInfo, exeErr := os.Stat(genBinExe) + if assert.NoError(t, exeErr, "statting the executable: %q", genBinExe) { + assert.True(t, exeInfo.Mode().IsRegular(), "executable is regular file") + // Check if the world-executable bit is set. + exePermMask := exeInfo.Mode().Perm() & 0o001 + assert.NotEqual(t, 0, exePermMask, "executable mask") + } + bufferBz := buffer.Collect() + bufferStr := string(bufferBz) + for _, exp := range expInLog { + assert.Contains(t, bufferStr, exp) + } + }) + + s.T().Run("genesis and upgrades exist but no current", func(t *testing.T) { + testDir := s.T().TempDir() + env := &cosmovisorInitEnv{ + Home: filepath.Join(testDir, "home"), + Name: "nocur", + } + rootDir := filepath.Join(env.Home, "cosmovisor") + genBinDir := filepath.Join(rootDir, "genesis", "bin") + genBinDirExe := filepath.Join(genBinDir, env.Name) + require.NoError(t, os.MkdirAll(genBinDir, 0o755), "making genesis bin dir") + require.NoError(t, copyFile(hwExe, genBinDirExe), "copying executable to genesis") + upgradesDir := filepath.Join(rootDir, "upgrades") + for i := 1; i <= 5; i++ { + upgradeBinDir := filepath.Join(upgradesDir, fmt.Sprintf("upgrade-%02d", i), "bin") + upgradeBinDirExe := filepath.Join(upgradeBinDir, env.Name) + require.NoErrorf(t, os.MkdirAll(upgradeBinDir, 0o755), "Making upgrade %d bin dir", i) + require.NoErrorf(t, copyFile(hwExe, upgradeBinDirExe), "copying executable to upgrade %d", i) + } + + expInLog := []string{ + "checking on the genesis/bin directory", + fmt.Sprintf("the %q directory already exists", genBinDir), + "checking on the genesis/bin executable", + fmt.Sprintf("the %q file already exists", genBinDirExe), + fmt.Sprintf("making sure %q is executable", genBinDirExe), + fmt.Sprintf("the current symlink points to: %q", genBinDirExe), + } + + s.setEnv(t, env) + buffer, logger := s.NewCapturingLogger() + logger.Info().Msgf("Calling InitializeCosmovisor: %s", t.Name()) + err := InitializeCosmovisor(logger, []string{hwExe}) + require.NoError(t, err, "calling InitializeCosmovisor") + bufferBz := buffer.Collect() + bufferStr := string(bufferBz) + for _, exp := range expInLog { + assert.Contains(t, bufferStr, exp) + } + }) + + s.T().Run("genesis bin dir exists empty", func(t *testing.T) { + testDir := s.T().TempDir() + env := &cosmovisorInitEnv{ + Home: filepath.Join(testDir, "home"), + Name: "emptygen", + } + rootDir := filepath.Join(env.Home, "cosmovisor") + genBinDir := filepath.Join(rootDir, "genesis", "bin") + genBinExe := filepath.Join(genBinDir, env.Name) + require.NoError(t, os.MkdirAll(genBinDir, 0o755), "making genesis bin dir") + + expInLog := []string{ + "checking on the genesis/bin directory", + fmt.Sprintf("the %q directory already exists", genBinDir), + "checking on the genesis/bin executable", + fmt.Sprintf("copying executable into place: %q", genBinExe), + fmt.Sprintf("making sure %q is executable", genBinExe), + fmt.Sprintf("the current symlink points to: %q", genBinExe), + } + + s.setEnv(t, env) + buffer, logger := s.NewCapturingLogger() + logger.Info().Msgf("Calling InitializeCosmovisor: %s", t.Name()) + err := InitializeCosmovisor(logger, []string{hwExe}) + require.NoError(t, err, "calling InitializeCosmovisor") + bufferBz := buffer.Collect() + bufferStr := string(bufferBz) + for _, exp := range expInLog { + assert.Contains(t, bufferStr, exp) + } + }) +} From b75c2ebcfab1a6b535723f1ac2889a2fc2509520 Mon Sep 17 00:00:00 2001 From: likhita-809 <78951027+likhita-809@users.noreply.github.com> Date: Thu, 7 Jul 2022 02:12:22 +0530 Subject: [PATCH 03/37] feat: deprecate x/params usage in x/slashing (#12399) --- CHANGELOG.md | 1 + api/cosmos/slashing/v1beta1/genesis.pulsar.go | 2 +- api/cosmos/slashing/v1beta1/tx.pulsar.go | 1073 ++++++++++++++++- api/cosmos/slashing/v1beta1/tx_grpc.pb.go | 44 + proto/cosmos/slashing/v1beta1/genesis.proto | 2 +- proto/cosmos/slashing/v1beta1/tx.proto | 28 + x/slashing/exported/exported.go | 18 + x/slashing/keeper/keeper.go | 32 +- x/slashing/keeper/keeper_test.go | 3 + x/slashing/keeper/migrations.go | 17 +- x/slashing/keeper/msg_server.go | 16 +- x/slashing/keeper/msg_server_test.go | 140 +++ x/slashing/keeper/params.go | 40 +- x/slashing/keeper/params_test.go | 119 ++ x/slashing/migrations/v2/migrate.go | 34 + x/slashing/migrations/v2/migrator_test.go | 46 + x/slashing/module.go | 43 +- x/slashing/types/codec.go | 3 + x/slashing/types/genesis.pb.go | 2 +- x/slashing/types/keys.go | 2 + x/slashing/types/msg.go | 29 +- x/slashing/types/params.go | 53 +- x/slashing/types/params_legacy.go | 39 + x/slashing/types/tx.pb.go | 484 +++++++- 24 files changed, 2134 insertions(+), 136 deletions(-) create mode 100644 x/slashing/exported/exported.go create mode 100644 x/slashing/keeper/msg_server_test.go create mode 100644 x/slashing/keeper/params_test.go create mode 100644 x/slashing/migrations/v2/migrate.go create mode 100644 x/slashing/migrations/v2/migrator_test.go create mode 100644 x/slashing/types/params_legacy.go diff --git a/CHANGELOG.md b/CHANGELOG.md index b4374fcc03fc..7c46e3cb1eeb 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -51,6 +51,7 @@ Ref: https://keepachangelog.com/en/1.0.0/ ### State Machine Breaking +* (x/slashing) [#12399](https://github.com/cosmos/cosmos-sdk/pull/12399) Migrate `x/slashing` to self-managed parameters and deprecate its usage of `x/params`. * (x/mint) [#12363](https://github.com/cosmos/cosmos-sdk/pull/12363) Migrate `x/mint` to self-managed parameters and deprecate it's usage of `x/params`. ### API Breaking Changes diff --git a/api/cosmos/slashing/v1beta1/genesis.pulsar.go b/api/cosmos/slashing/v1beta1/genesis.pulsar.go index 490d3d584d3e..16ded99669b4 100644 --- a/api/cosmos/slashing/v1beta1/genesis.pulsar.go +++ b/api/cosmos/slashing/v1beta1/genesis.pulsar.go @@ -2259,7 +2259,7 @@ type GenesisState struct { sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // params defines all the paramaters of related to deposit. + // params defines all the parameters of the module. Params *Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params,omitempty"` // signing_infos represents a map between validator addresses and their // signing infos. diff --git a/api/cosmos/slashing/v1beta1/tx.pulsar.go b/api/cosmos/slashing/v1beta1/tx.pulsar.go index dcb0668d8196..3e96c48f1866 100644 --- a/api/cosmos/slashing/v1beta1/tx.pulsar.go +++ b/api/cosmos/slashing/v1beta1/tx.pulsar.go @@ -791,6 +791,861 @@ func (x *fastReflection_MsgUnjailResponse) ProtoMethods() *protoiface.Methods { } } +var ( + md_MsgUpdateParams protoreflect.MessageDescriptor + fd_MsgUpdateParams_authority protoreflect.FieldDescriptor + fd_MsgUpdateParams_params protoreflect.FieldDescriptor +) + +func init() { + file_cosmos_slashing_v1beta1_tx_proto_init() + md_MsgUpdateParams = File_cosmos_slashing_v1beta1_tx_proto.Messages().ByName("MsgUpdateParams") + fd_MsgUpdateParams_authority = md_MsgUpdateParams.Fields().ByName("authority") + fd_MsgUpdateParams_params = md_MsgUpdateParams.Fields().ByName("params") +} + +var _ protoreflect.Message = (*fastReflection_MsgUpdateParams)(nil) + +type fastReflection_MsgUpdateParams MsgUpdateParams + +func (x *MsgUpdateParams) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgUpdateParams)(x) +} + +func (x *MsgUpdateParams) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_slashing_v1beta1_tx_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_MsgUpdateParams_messageType fastReflection_MsgUpdateParams_messageType +var _ protoreflect.MessageType = fastReflection_MsgUpdateParams_messageType{} + +type fastReflection_MsgUpdateParams_messageType struct{} + +func (x fastReflection_MsgUpdateParams_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgUpdateParams)(nil) +} +func (x fastReflection_MsgUpdateParams_messageType) New() protoreflect.Message { + return new(fastReflection_MsgUpdateParams) +} +func (x fastReflection_MsgUpdateParams_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgUpdateParams +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgUpdateParams) Descriptor() protoreflect.MessageDescriptor { + return md_MsgUpdateParams +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_MsgUpdateParams) Type() protoreflect.MessageType { + return _fastReflection_MsgUpdateParams_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgUpdateParams) New() protoreflect.Message { + return new(fastReflection_MsgUpdateParams) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgUpdateParams) Interface() protoreflect.ProtoMessage { + return (*MsgUpdateParams)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_MsgUpdateParams) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Authority != "" { + value := protoreflect.ValueOfString(x.Authority) + if !f(fd_MsgUpdateParams_authority, value) { + return + } + } + if x.Params != nil { + value := protoreflect.ValueOfMessage(x.Params.ProtoReflect()) + if !f(fd_MsgUpdateParams_params, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_MsgUpdateParams) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "cosmos.slashing.v1beta1.MsgUpdateParams.authority": + return x.Authority != "" + case "cosmos.slashing.v1beta1.MsgUpdateParams.params": + return x.Params != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.slashing.v1beta1.MsgUpdateParams")) + } + panic(fmt.Errorf("message cosmos.slashing.v1beta1.MsgUpdateParams does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_MsgUpdateParams) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "cosmos.slashing.v1beta1.MsgUpdateParams.authority": + x.Authority = "" + case "cosmos.slashing.v1beta1.MsgUpdateParams.params": + x.Params = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.slashing.v1beta1.MsgUpdateParams")) + } + panic(fmt.Errorf("message cosmos.slashing.v1beta1.MsgUpdateParams does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_MsgUpdateParams) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "cosmos.slashing.v1beta1.MsgUpdateParams.authority": + value := x.Authority + return protoreflect.ValueOfString(value) + case "cosmos.slashing.v1beta1.MsgUpdateParams.params": + value := x.Params + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.slashing.v1beta1.MsgUpdateParams")) + } + panic(fmt.Errorf("message cosmos.slashing.v1beta1.MsgUpdateParams does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_MsgUpdateParams) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "cosmos.slashing.v1beta1.MsgUpdateParams.authority": + x.Authority = value.Interface().(string) + case "cosmos.slashing.v1beta1.MsgUpdateParams.params": + x.Params = value.Message().Interface().(*Params) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.slashing.v1beta1.MsgUpdateParams")) + } + panic(fmt.Errorf("message cosmos.slashing.v1beta1.MsgUpdateParams does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_MsgUpdateParams) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.slashing.v1beta1.MsgUpdateParams.params": + if x.Params == nil { + x.Params = new(Params) + } + return protoreflect.ValueOfMessage(x.Params.ProtoReflect()) + case "cosmos.slashing.v1beta1.MsgUpdateParams.authority": + panic(fmt.Errorf("field authority of message cosmos.slashing.v1beta1.MsgUpdateParams is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.slashing.v1beta1.MsgUpdateParams")) + } + panic(fmt.Errorf("message cosmos.slashing.v1beta1.MsgUpdateParams does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_MsgUpdateParams) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.slashing.v1beta1.MsgUpdateParams.authority": + return protoreflect.ValueOfString("") + case "cosmos.slashing.v1beta1.MsgUpdateParams.params": + m := new(Params) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.slashing.v1beta1.MsgUpdateParams")) + } + panic(fmt.Errorf("message cosmos.slashing.v1beta1.MsgUpdateParams does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_MsgUpdateParams) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.slashing.v1beta1.MsgUpdateParams", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_MsgUpdateParams) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_MsgUpdateParams) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_MsgUpdateParams) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_MsgUpdateParams) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgUpdateParams) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + l = len(x.Authority) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.Params != nil { + l = options.Size(x.Params) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*MsgUpdateParams) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if x.Params != nil { + encoded, err := options.Marshal(x.Params) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x12 + } + if len(x.Authority) > 0 { + i -= len(x.Authority) + copy(dAtA[i:], x.Authority) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Authority))) + i-- + dAtA[i] = 0xa + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*MsgUpdateParams) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUpdateParams: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUpdateParams: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Authority = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Params", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.Params == nil { + x.Params = &Params{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Params); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_MsgUpdateParamsResponse protoreflect.MessageDescriptor +) + +func init() { + file_cosmos_slashing_v1beta1_tx_proto_init() + md_MsgUpdateParamsResponse = File_cosmos_slashing_v1beta1_tx_proto.Messages().ByName("MsgUpdateParamsResponse") +} + +var _ protoreflect.Message = (*fastReflection_MsgUpdateParamsResponse)(nil) + +type fastReflection_MsgUpdateParamsResponse MsgUpdateParamsResponse + +func (x *MsgUpdateParamsResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgUpdateParamsResponse)(x) +} + +func (x *MsgUpdateParamsResponse) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_slashing_v1beta1_tx_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_MsgUpdateParamsResponse_messageType fastReflection_MsgUpdateParamsResponse_messageType +var _ protoreflect.MessageType = fastReflection_MsgUpdateParamsResponse_messageType{} + +type fastReflection_MsgUpdateParamsResponse_messageType struct{} + +func (x fastReflection_MsgUpdateParamsResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgUpdateParamsResponse)(nil) +} +func (x fastReflection_MsgUpdateParamsResponse_messageType) New() protoreflect.Message { + return new(fastReflection_MsgUpdateParamsResponse) +} +func (x fastReflection_MsgUpdateParamsResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgUpdateParamsResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgUpdateParamsResponse) Descriptor() protoreflect.MessageDescriptor { + return md_MsgUpdateParamsResponse +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_MsgUpdateParamsResponse) Type() protoreflect.MessageType { + return _fastReflection_MsgUpdateParamsResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgUpdateParamsResponse) New() protoreflect.Message { + return new(fastReflection_MsgUpdateParamsResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgUpdateParamsResponse) Interface() protoreflect.ProtoMessage { + return (*MsgUpdateParamsResponse)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_MsgUpdateParamsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_MsgUpdateParamsResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.slashing.v1beta1.MsgUpdateParamsResponse")) + } + panic(fmt.Errorf("message cosmos.slashing.v1beta1.MsgUpdateParamsResponse does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_MsgUpdateParamsResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.slashing.v1beta1.MsgUpdateParamsResponse")) + } + panic(fmt.Errorf("message cosmos.slashing.v1beta1.MsgUpdateParamsResponse does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_MsgUpdateParamsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.slashing.v1beta1.MsgUpdateParamsResponse")) + } + panic(fmt.Errorf("message cosmos.slashing.v1beta1.MsgUpdateParamsResponse does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_MsgUpdateParamsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.slashing.v1beta1.MsgUpdateParamsResponse")) + } + panic(fmt.Errorf("message cosmos.slashing.v1beta1.MsgUpdateParamsResponse does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_MsgUpdateParamsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.slashing.v1beta1.MsgUpdateParamsResponse")) + } + panic(fmt.Errorf("message cosmos.slashing.v1beta1.MsgUpdateParamsResponse does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_MsgUpdateParamsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.slashing.v1beta1.MsgUpdateParamsResponse")) + } + panic(fmt.Errorf("message cosmos.slashing.v1beta1.MsgUpdateParamsResponse does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_MsgUpdateParamsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.slashing.v1beta1.MsgUpdateParamsResponse", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_MsgUpdateParamsResponse) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_MsgUpdateParamsResponse) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_MsgUpdateParamsResponse) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_MsgUpdateParamsResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgUpdateParamsResponse) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*MsgUpdateParamsResponse) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*MsgUpdateParamsResponse) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUpdateParamsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUpdateParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.27.0 @@ -867,6 +1722,86 @@ func (*MsgUnjailResponse) Descriptor() ([]byte, []int) { return file_cosmos_slashing_v1beta1_tx_proto_rawDescGZIP(), []int{1} } +// MsgUpdateParams is the Msg/UpdateParams request type. +// +// Since: cosmos-sdk 0.47 +type MsgUpdateParams struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // authority is the address of the governance account. + Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"` + // params defines the x/slashing parameters to update. + // + // NOTE: All parameters must be supplied. + Params *Params `protobuf:"bytes,2,opt,name=params,proto3" json:"params,omitempty"` +} + +func (x *MsgUpdateParams) Reset() { + *x = MsgUpdateParams{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_slashing_v1beta1_tx_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgUpdateParams) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgUpdateParams) ProtoMessage() {} + +// Deprecated: Use MsgUpdateParams.ProtoReflect.Descriptor instead. +func (*MsgUpdateParams) Descriptor() ([]byte, []int) { + return file_cosmos_slashing_v1beta1_tx_proto_rawDescGZIP(), []int{2} +} + +func (x *MsgUpdateParams) GetAuthority() string { + if x != nil { + return x.Authority + } + return "" +} + +func (x *MsgUpdateParams) GetParams() *Params { + if x != nil { + return x.Params + } + return nil +} + +// MsgUpdateParamsResponse defines the response structure for executing a +// MsgUpdateParams message. +// +// Since: cosmos-sdk 0.47 +type MsgUpdateParamsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *MsgUpdateParamsResponse) Reset() { + *x = MsgUpdateParamsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_slashing_v1beta1_tx_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgUpdateParamsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgUpdateParamsResponse) ProtoMessage() {} + +// Deprecated: Use MsgUpdateParamsResponse.ProtoReflect.Descriptor instead. +func (*MsgUpdateParamsResponse) Descriptor() ([]byte, []int) { + return file_cosmos_slashing_v1beta1_tx_proto_rawDescGZIP(), []int{3} +} + var File_cosmos_slashing_v1beta1_tx_proto protoreflect.FileDescriptor var file_cosmos_slashing_v1beta1_tx_proto_rawDesc = []byte{ @@ -875,39 +1810,60 @@ var file_cosmos_slashing_v1beta1_tx_proto_rawDesc = []byte{ 0x74, 0x6f, 0x12, 0x17, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x1a, 0x14, 0x67, 0x6f, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x1a, 0x19, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, - 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x17, 0x63, 0x6f, - 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x6d, 0x73, 0x67, 0x2f, 0x76, 0x31, 0x2f, 0x6d, 0x73, 0x67, 0x2e, - 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x74, 0x0a, 0x09, 0x4d, 0x73, 0x67, 0x55, 0x6e, 0x6a, 0x61, - 0x69, 0x6c, 0x12, 0x4a, 0x0a, 0x0e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x5f, - 0x61, 0x64, 0x64, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x23, 0xea, 0xde, 0x1f, 0x07, - 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f, - 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, - 0x0d, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x3a, 0x1b, - 0x88, 0xa0, 0x1f, 0x00, 0x98, 0xa0, 0x1f, 0x01, 0x82, 0xe7, 0xb0, 0x2a, 0x0e, 0x76, 0x61, 0x6c, - 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x22, 0x13, 0x0a, 0x11, 0x4d, + 0x6f, 0x1a, 0x26, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x73, 0x6c, 0x61, 0x73, 0x68, 0x69, + 0x6e, 0x67, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x73, 0x6c, 0x61, 0x73, 0x68, + 0x69, 0x6e, 0x67, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x19, 0x63, 0x6f, 0x73, 0x6d, 0x6f, + 0x73, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x17, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x6d, 0x73, 0x67, + 0x2f, 0x76, 0x31, 0x2f, 0x6d, 0x73, 0x67, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x74, 0x0a, + 0x09, 0x4d, 0x73, 0x67, 0x55, 0x6e, 0x6a, 0x61, 0x69, 0x6c, 0x12, 0x4a, 0x0a, 0x0e, 0x76, 0x61, + 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x42, 0x23, 0xea, 0xde, 0x1f, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0xd2, + 0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, + 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x0d, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, + 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x3a, 0x1b, 0x88, 0xa0, 0x1f, 0x00, 0x98, 0xa0, 0x1f, 0x01, + 0x82, 0xe7, 0xb0, 0x2a, 0x0e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, + 0x64, 0x64, 0x72, 0x22, 0x13, 0x0a, 0x11, 0x4d, 0x73, 0x67, 0x55, 0x6e, 0x6a, 0x61, 0x69, 0x6c, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x98, 0x01, 0x0a, 0x0f, 0x4d, 0x73, 0x67, + 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x36, 0x0a, 0x09, + 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, + 0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, + 0x72, 0x69, 0x74, 0x79, 0x12, 0x3d, 0x0a, 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x6c, + 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, + 0x61, 0x72, 0x61, 0x6d, 0x73, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x06, 0x70, 0x61, 0x72, + 0x61, 0x6d, 0x73, 0x3a, 0x0e, 0x82, 0xe7, 0xb0, 0x2a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, + 0x69, 0x74, 0x79, 0x22, 0x19, 0x0a, 0x17, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, + 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x32, 0xcb, + 0x01, 0x0a, 0x03, 0x4d, 0x73, 0x67, 0x12, 0x58, 0x0a, 0x06, 0x55, 0x6e, 0x6a, 0x61, 0x69, 0x6c, + 0x12, 0x22, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x6c, 0x61, 0x73, 0x68, 0x69, + 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x6e, + 0x6a, 0x61, 0x69, 0x6c, 0x1a, 0x2a, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x6c, + 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x6e, 0x6a, 0x61, 0x69, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x32, 0x5f, 0x0a, 0x03, 0x4d, 0x73, 0x67, 0x12, 0x58, 0x0a, 0x06, 0x55, 0x6e, 0x6a, 0x61, 0x69, - 0x6c, 0x12, 0x22, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x6c, 0x61, 0x73, 0x68, - 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x55, - 0x6e, 0x6a, 0x61, 0x69, 0x6c, 0x1a, 0x2a, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, - 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, - 0x4d, 0x73, 0x67, 0x55, 0x6e, 0x6a, 0x61, 0x69, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x42, 0xe2, 0x01, 0x0a, 0x1b, 0x63, 0x6f, 0x6d, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, - 0x2e, 0x73, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, - 0x31, 0x42, 0x07, 0x54, 0x78, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x38, 0x63, 0x6f, - 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x63, - 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x73, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x2f, 0x76, - 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x3b, 0x73, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x76, - 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0xa2, 0x02, 0x03, 0x43, 0x53, 0x58, 0xaa, 0x02, 0x17, 0x43, - 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x53, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x2e, 0x56, - 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0xca, 0x02, 0x17, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5c, - 0x53, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x5c, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, - 0xe2, 0x02, 0x23, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x53, 0x6c, 0x61, 0x73, 0x68, 0x69, - 0x6e, 0x67, 0x5c, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, - 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x19, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x3a, - 0x3a, 0x53, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x65, 0x74, - 0x61, 0x31, 0xa8, 0xe2, 0x1e, 0x01, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x12, 0x6a, 0x0a, 0x0c, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, + 0x12, 0x28, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x6c, 0x61, 0x73, 0x68, 0x69, + 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x70, + 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x1a, 0x30, 0x2e, 0x63, 0x6f, 0x73, + 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, + 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, + 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0xe2, 0x01, 0x0a, + 0x1b, 0x63, 0x6f, 0x6d, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x73, 0x6c, 0x61, 0x73, + 0x68, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x42, 0x07, 0x54, 0x78, + 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x38, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, + 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, + 0x2f, 0x73, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, + 0x31, 0x3b, 0x73, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, + 0x31, 0xa2, 0x02, 0x03, 0x43, 0x53, 0x58, 0xaa, 0x02, 0x17, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, + 0x2e, 0x53, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x2e, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, + 0x31, 0xca, 0x02, 0x17, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x53, 0x6c, 0x61, 0x73, 0x68, + 0x69, 0x6e, 0x67, 0x5c, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0xe2, 0x02, 0x23, 0x43, 0x6f, + 0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x53, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x5c, 0x56, 0x31, + 0x62, 0x65, 0x74, 0x61, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0xea, 0x02, 0x19, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x3a, 0x3a, 0x53, 0x6c, 0x61, 0x73, + 0x68, 0x69, 0x6e, 0x67, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0xa8, 0xe2, 0x1e, + 0x01, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var ( @@ -922,19 +1878,25 @@ func file_cosmos_slashing_v1beta1_tx_proto_rawDescGZIP() []byte { return file_cosmos_slashing_v1beta1_tx_proto_rawDescData } -var file_cosmos_slashing_v1beta1_tx_proto_msgTypes = make([]protoimpl.MessageInfo, 2) +var file_cosmos_slashing_v1beta1_tx_proto_msgTypes = make([]protoimpl.MessageInfo, 4) var file_cosmos_slashing_v1beta1_tx_proto_goTypes = []interface{}{ - (*MsgUnjail)(nil), // 0: cosmos.slashing.v1beta1.MsgUnjail - (*MsgUnjailResponse)(nil), // 1: cosmos.slashing.v1beta1.MsgUnjailResponse + (*MsgUnjail)(nil), // 0: cosmos.slashing.v1beta1.MsgUnjail + (*MsgUnjailResponse)(nil), // 1: cosmos.slashing.v1beta1.MsgUnjailResponse + (*MsgUpdateParams)(nil), // 2: cosmos.slashing.v1beta1.MsgUpdateParams + (*MsgUpdateParamsResponse)(nil), // 3: cosmos.slashing.v1beta1.MsgUpdateParamsResponse + (*Params)(nil), // 4: cosmos.slashing.v1beta1.Params } var file_cosmos_slashing_v1beta1_tx_proto_depIdxs = []int32{ - 0, // 0: cosmos.slashing.v1beta1.Msg.Unjail:input_type -> cosmos.slashing.v1beta1.MsgUnjail - 1, // 1: cosmos.slashing.v1beta1.Msg.Unjail:output_type -> cosmos.slashing.v1beta1.MsgUnjailResponse - 1, // [1:2] is the sub-list for method output_type - 0, // [0:1] is the sub-list for method input_type - 0, // [0:0] is the sub-list for extension type_name - 0, // [0:0] is the sub-list for extension extendee - 0, // [0:0] is the sub-list for field type_name + 4, // 0: cosmos.slashing.v1beta1.MsgUpdateParams.params:type_name -> cosmos.slashing.v1beta1.Params + 0, // 1: cosmos.slashing.v1beta1.Msg.Unjail:input_type -> cosmos.slashing.v1beta1.MsgUnjail + 2, // 2: cosmos.slashing.v1beta1.Msg.UpdateParams:input_type -> cosmos.slashing.v1beta1.MsgUpdateParams + 1, // 3: cosmos.slashing.v1beta1.Msg.Unjail:output_type -> cosmos.slashing.v1beta1.MsgUnjailResponse + 3, // 4: cosmos.slashing.v1beta1.Msg.UpdateParams:output_type -> cosmos.slashing.v1beta1.MsgUpdateParamsResponse + 3, // [3:5] is the sub-list for method output_type + 1, // [1:3] is the sub-list for method input_type + 1, // [1:1] is the sub-list for extension type_name + 1, // [1:1] is the sub-list for extension extendee + 0, // [0:1] is the sub-list for field type_name } func init() { file_cosmos_slashing_v1beta1_tx_proto_init() } @@ -942,6 +1904,7 @@ func file_cosmos_slashing_v1beta1_tx_proto_init() { if File_cosmos_slashing_v1beta1_tx_proto != nil { return } + file_cosmos_slashing_v1beta1_slashing_proto_init() if !protoimpl.UnsafeEnabled { file_cosmos_slashing_v1beta1_tx_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*MsgUnjail); i { @@ -967,6 +1930,30 @@ func file_cosmos_slashing_v1beta1_tx_proto_init() { return nil } } + file_cosmos_slashing_v1beta1_tx_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgUpdateParams); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cosmos_slashing_v1beta1_tx_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgUpdateParamsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } } type x struct{} out := protoimpl.TypeBuilder{ @@ -974,7 +1961,7 @@ func file_cosmos_slashing_v1beta1_tx_proto_init() { GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: file_cosmos_slashing_v1beta1_tx_proto_rawDesc, NumEnums: 0, - NumMessages: 2, + NumMessages: 4, NumExtensions: 0, NumServices: 1, }, diff --git a/api/cosmos/slashing/v1beta1/tx_grpc.pb.go b/api/cosmos/slashing/v1beta1/tx_grpc.pb.go index e3a9756f3310..ec287ea88ede 100644 --- a/api/cosmos/slashing/v1beta1/tx_grpc.pb.go +++ b/api/cosmos/slashing/v1beta1/tx_grpc.pb.go @@ -26,6 +26,11 @@ type MsgClient interface { // them into the bonded validator set, so they can begin receiving provisions // and rewards again. Unjail(ctx context.Context, in *MsgUnjail, opts ...grpc.CallOption) (*MsgUnjailResponse, error) + // UpdateParams defines a governance operation for updating the x/slashing module + // parameters. The authority is hard-coded to the x/gov module account. + // + // Since: cosmos-sdk 0.47 + UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) } type msgClient struct { @@ -45,6 +50,15 @@ func (c *msgClient) Unjail(ctx context.Context, in *MsgUnjail, opts ...grpc.Call return out, nil } +func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) { + out := new(MsgUpdateParamsResponse) + err := c.cc.Invoke(ctx, "/cosmos.slashing.v1beta1.Msg/UpdateParams", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // MsgServer is the server API for Msg service. // All implementations must embed UnimplementedMsgServer // for forward compatibility @@ -53,6 +67,11 @@ type MsgServer interface { // them into the bonded validator set, so they can begin receiving provisions // and rewards again. Unjail(context.Context, *MsgUnjail) (*MsgUnjailResponse, error) + // UpdateParams defines a governance operation for updating the x/slashing module + // parameters. The authority is hard-coded to the x/gov module account. + // + // Since: cosmos-sdk 0.47 + UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error) mustEmbedUnimplementedMsgServer() } @@ -63,6 +82,9 @@ type UnimplementedMsgServer struct { func (UnimplementedMsgServer) Unjail(context.Context, *MsgUnjail) (*MsgUnjailResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Unjail not implemented") } +func (UnimplementedMsgServer) UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateParams not implemented") +} func (UnimplementedMsgServer) mustEmbedUnimplementedMsgServer() {} // UnsafeMsgServer may be embedded to opt out of forward compatibility for this service. @@ -94,6 +116,24 @@ func _Msg_Unjail_Handler(srv interface{}, ctx context.Context, dec func(interfac return interceptor(ctx, in, info, handler) } +func _Msg_UpdateParams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgUpdateParams) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).UpdateParams(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmos.slashing.v1beta1.Msg/UpdateParams", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).UpdateParams(ctx, req.(*MsgUpdateParams)) + } + return interceptor(ctx, in, info, handler) +} + // Msg_ServiceDesc is the grpc.ServiceDesc for Msg service. // It's only intended for direct use with grpc.RegisterService, // and not to be introspected or modified (even as a copy) @@ -105,6 +145,10 @@ var Msg_ServiceDesc = grpc.ServiceDesc{ MethodName: "Unjail", Handler: _Msg_Unjail_Handler, }, + { + MethodName: "UpdateParams", + Handler: _Msg_UpdateParams_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "cosmos/slashing/v1beta1/tx.proto", diff --git a/proto/cosmos/slashing/v1beta1/genesis.proto b/proto/cosmos/slashing/v1beta1/genesis.proto index 312d56aa2fbf..cf5a4ba38ef2 100644 --- a/proto/cosmos/slashing/v1beta1/genesis.proto +++ b/proto/cosmos/slashing/v1beta1/genesis.proto @@ -9,7 +9,7 @@ import "cosmos_proto/cosmos.proto"; // GenesisState defines the slashing module's genesis state. message GenesisState { - // params defines all the paramaters of related to deposit. + // params defines all the parameters of the module. Params params = 1 [(gogoproto.nullable) = false]; // signing_infos represents a map between validator addresses and their diff --git a/proto/cosmos/slashing/v1beta1/tx.proto b/proto/cosmos/slashing/v1beta1/tx.proto index 7c90304b84bc..26c24b3c3b7c 100644 --- a/proto/cosmos/slashing/v1beta1/tx.proto +++ b/proto/cosmos/slashing/v1beta1/tx.proto @@ -5,6 +5,7 @@ option go_package = "github.com/cosmos/cosmos-sdk/x/slashing/types"; option (gogoproto.equal_all) = true; import "gogoproto/gogo.proto"; +import "cosmos/slashing/v1beta1/slashing.proto"; import "cosmos_proto/cosmos.proto"; import "cosmos/msg/v1/msg.proto"; @@ -14,6 +15,12 @@ service Msg { // them into the bonded validator set, so they can begin receiving provisions // and rewards again. rpc Unjail(MsgUnjail) returns (MsgUnjailResponse); + + // UpdateParams defines a governance operation for updating the x/slashing module + // parameters. The authority is hard-coded to the x/gov module account. + // + // Since: cosmos-sdk 0.47 + rpc UpdateParams(MsgUpdateParams) returns (MsgUpdateParamsResponse); } // MsgUnjail defines the Msg/Unjail request type @@ -28,3 +35,24 @@ message MsgUnjail { // MsgUnjailResponse defines the Msg/Unjail response type message MsgUnjailResponse {} + +// MsgUpdateParams is the Msg/UpdateParams request type. +// +// Since: cosmos-sdk 0.47 +message MsgUpdateParams { + option (cosmos.msg.v1.signer) = "authority"; + + // authority is the address of the governance account. + string authority = 1 [(cosmos_proto.scalar) = "cosmos.AddressString"]; + + // params defines the x/slashing parameters to update. + // + // NOTE: All parameters must be supplied. + Params params = 2 [(gogoproto.nullable) = false]; +} + +// MsgUpdateParamsResponse defines the response structure for executing a +// MsgUpdateParams message. +// +// Since: cosmos-sdk 0.47 +message MsgUpdateParamsResponse {} diff --git a/x/slashing/exported/exported.go b/x/slashing/exported/exported.go new file mode 100644 index 000000000000..000114e6194d --- /dev/null +++ b/x/slashing/exported/exported.go @@ -0,0 +1,18 @@ +package exported + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" +) + +type ( + ParamSet = paramtypes.ParamSet + + // Subspace defines an interface that implements the legacy x/params Subspace + // type. + // + // NOTE: This is used solely for migration of x/params managed parameters. + Subspace interface { + GetParamSet(ctx sdk.Context, ps ParamSet) + } +) diff --git a/x/slashing/keeper/keeper.go b/x/slashing/keeper/keeper.go index dbec306bfda1..89b97367507f 100644 --- a/x/slashing/keeper/keeper.go +++ b/x/slashing/keeper/keeper.go @@ -14,27 +14,33 @@ import ( // Keeper of the slashing store type Keeper struct { - storeKey storetypes.StoreKey - cdc codec.BinaryCodec - sk types.StakingKeeper - paramspace types.ParamSubspace + storeKey storetypes.StoreKey + cdc codec.BinaryCodec + legacyAmino *codec.LegacyAmino + sk types.StakingKeeper + + // the address capable of executing a MsgUpdateParams message. Typically, this + // should be the x/gov module account. + authority string } // NewKeeper creates a slashing keeper -func NewKeeper(cdc codec.BinaryCodec, key storetypes.StoreKey, sk types.StakingKeeper, paramspace types.ParamSubspace) Keeper { - // set KeyTable if it has not already been set - if !paramspace.HasKeyTable() { - paramspace = paramspace.WithKeyTable(types.ParamKeyTable()) - } +func NewKeeper(cdc codec.BinaryCodec, legacyAmino *codec.LegacyAmino, key storetypes.StoreKey, sk types.StakingKeeper, authority string) Keeper { return Keeper{ - storeKey: key, - cdc: cdc, - sk: sk, - paramspace: paramspace, + storeKey: key, + cdc: cdc, + legacyAmino: legacyAmino, + sk: sk, + authority: authority, } } +// GetAuthority returns the x/slashing module's authority. +func (k Keeper) GetAuthority() string { + return k.authority +} + // Logger returns a module-specific logger. func (k Keeper) Logger(ctx sdk.Context) log.Logger { return ctx.Logger().With("module", "x/"+types.ModuleName) diff --git a/x/slashing/keeper/keeper_test.go b/x/slashing/keeper/keeper_test.go index 09be0e93106a..622510dd690e 100644 --- a/x/slashing/keeper/keeper_test.go +++ b/x/slashing/keeper/keeper_test.go @@ -37,6 +37,7 @@ type KeeperTestSuite struct { interfaceRegistry codectypes.InterfaceRegistry addrDels []sdk.AccAddress queryClient slashingtypes.QueryClient + msgServer types.MsgServer } func (s *KeeperTestSuite) SetupTest() { @@ -49,6 +50,7 @@ func (s *KeeperTestSuite) SetupTest() { &s.interfaceRegistry, ) s.Require().NoError(err) + ctx := app.BaseApp.NewContext(false, tmproto.Header{}) s.accountKeeper.SetParams(ctx, authtypes.DefaultParams()) @@ -72,6 +74,7 @@ func (s *KeeperTestSuite) SetupTest() { s.addrDels = addrDels s.ctx = ctx + s.msgServer = slashingkeeper.NewMsgServerImpl(s.slashingKeeper) } func (s *KeeperTestSuite) TestUnJailNotBonded() { diff --git a/x/slashing/keeper/migrations.go b/x/slashing/keeper/migrations.go index a9f74f6ace75..d06a372262ad 100644 --- a/x/slashing/keeper/migrations.go +++ b/x/slashing/keeper/migrations.go @@ -2,20 +2,31 @@ package keeper import ( sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/slashing/exported" v043 "github.com/cosmos/cosmos-sdk/x/slashing/migrations/v043" + v2 "github.com/cosmos/cosmos-sdk/x/slashing/migrations/v2" ) // Migrator is a struct for handling in-place store migrations. type Migrator struct { - keeper Keeper + keeper Keeper + legacySubspace exported.Subspace } // NewMigrator returns a new Migrator. -func NewMigrator(keeper Keeper) Migrator { - return Migrator{keeper: keeper} +func NewMigrator(keeper Keeper, ss exported.Subspace) Migrator { + return Migrator{keeper: keeper, legacySubspace: ss} } // Migrate1to2 migrates from version 1 to 2. func (m Migrator) Migrate1to2(ctx sdk.Context) error { return v043.MigrateStore(ctx, m.keeper.storeKey) } + +// Migrate2to3 migrates the x/slashing module state from the consensus +// version 2 to version 3. Specifically, it takes the parameters that are currently stored +// and managed by the x/params modules and stores them directly into the x/slashing +// module state. +func (m Migrator) Migrate2to3(ctx sdk.Context) error { + return v2.Migrate(ctx, ctx.KVStore(m.keeper.storeKey), m.legacySubspace, m.keeper.cdc) +} diff --git a/x/slashing/keeper/msg_server.go b/x/slashing/keeper/msg_server.go index 90a2558384a3..e77c524c1ab7 100644 --- a/x/slashing/keeper/msg_server.go +++ b/x/slashing/keeper/msg_server.go @@ -4,9 +4,13 @@ import ( "context" sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/errors" + govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" "github.com/cosmos/cosmos-sdk/x/slashing/types" ) +var _ types.MsgServer = msgServer{} + type msgServer struct { Keeper } @@ -17,7 +21,17 @@ func NewMsgServerImpl(keeper Keeper) types.MsgServer { return &msgServer{Keeper: keeper} } -var _ types.MsgServer = msgServer{} +func (k msgServer) UpdateParams(goCtx context.Context, req *types.MsgUpdateParams) (*types.MsgUpdateParamsResponse, error) { + if k.authority != req.Authority { + return nil, errors.Wrapf(govtypes.ErrInvalidSigner, "invalid authority; expected %s, got %s", k.authority, req.Authority) + } + ctx := sdk.UnwrapSDKContext(goCtx) + if err := k.SetParams(ctx, req.Params); err != nil { + return nil, err + } + + return &types.MsgUpdateParamsResponse{}, nil +} // Unjail implements MsgServer.Unjail method. // Validators must submit a transaction to unjail itself after diff --git a/x/slashing/keeper/msg_server_test.go b/x/slashing/keeper/msg_server_test.go new file mode 100644 index 000000000000..926bd8c3832f --- /dev/null +++ b/x/slashing/keeper/msg_server_test.go @@ -0,0 +1,140 @@ +package keeper_test + +import ( + "time" + + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/slashing/types" +) + +func (s *KeeperTestSuite) TestUpdateParams() { + minSignedPerWindow, err := sdk.NewDecFromStr("0.60") + s.Require().NoError(err) + + slashFractionDoubleSign, err := sdk.NewDecFromStr("0.022") + s.Require().NoError(err) + + slashFractionDowntime, err := sdk.NewDecFromStr("0.0089") + s.Require().NoError(err) + + invalidVal, err := sdk.NewDecFromStr("-1") + s.Require().NoError(err) + + testCases := []struct { + name string + request *types.MsgUpdateParams + expectErr bool + expErrMsg string + }{ + { + name: "set invalid authority", + request: &types.MsgUpdateParams{ + Authority: "foo", + }, + expectErr: true, + expErrMsg: "invalid authority", + }, + { + name: "set invalid signed blocks window", + request: &types.MsgUpdateParams{ + Authority: s.slashingKeeper.GetAuthority(), + Params: types.Params{ + SignedBlocksWindow: 0, + MinSignedPerWindow: minSignedPerWindow, + DowntimeJailDuration: time.Duration(34800000000000), + SlashFractionDoubleSign: slashFractionDoubleSign, + SlashFractionDowntime: slashFractionDowntime, + }, + }, + expectErr: true, + expErrMsg: "signed blocks window must be positive", + }, + { + name: "set invalid min signed per window", + request: &types.MsgUpdateParams{ + Authority: s.slashingKeeper.GetAuthority(), + Params: types.Params{ + SignedBlocksWindow: int64(750), + MinSignedPerWindow: invalidVal, + DowntimeJailDuration: time.Duration(34800000000000), + SlashFractionDoubleSign: slashFractionDoubleSign, + SlashFractionDowntime: slashFractionDowntime, + }, + }, + expectErr: true, + expErrMsg: "min signed per window cannot be negative", + }, + { + name: "set invalid downtime jail duration", + request: &types.MsgUpdateParams{ + Authority: s.slashingKeeper.GetAuthority(), + Params: types.Params{ + SignedBlocksWindow: int64(750), + MinSignedPerWindow: minSignedPerWindow, + DowntimeJailDuration: time.Duration(0), + SlashFractionDoubleSign: slashFractionDoubleSign, + SlashFractionDowntime: slashFractionDowntime, + }, + }, + expectErr: true, + expErrMsg: "downtime jail duration must be positive", + }, + { + name: "set invalid slash fraction double sign", + request: &types.MsgUpdateParams{ + Authority: s.slashingKeeper.GetAuthority(), + Params: types.Params{ + SignedBlocksWindow: int64(750), + MinSignedPerWindow: minSignedPerWindow, + DowntimeJailDuration: time.Duration(10), + SlashFractionDoubleSign: invalidVal, + SlashFractionDowntime: slashFractionDowntime, + }, + }, + expectErr: true, + expErrMsg: "double sign slash fraction cannot be negative", + }, + { + name: "set invalid slash fraction downtime", + request: &types.MsgUpdateParams{ + Authority: s.slashingKeeper.GetAuthority(), + Params: types.Params{ + SignedBlocksWindow: int64(750), + MinSignedPerWindow: minSignedPerWindow, + DowntimeJailDuration: time.Duration(10), + SlashFractionDoubleSign: slashFractionDoubleSign, + SlashFractionDowntime: invalidVal, + }, + }, + expectErr: true, + expErrMsg: "downtime slash fraction cannot be negative", + }, + { + name: "set full valid params", + request: &types.MsgUpdateParams{ + Authority: s.slashingKeeper.GetAuthority(), + Params: types.Params{ + SignedBlocksWindow: int64(750), + MinSignedPerWindow: minSignedPerWindow, + DowntimeJailDuration: time.Duration(34800000000000), + SlashFractionDoubleSign: slashFractionDoubleSign, + SlashFractionDowntime: slashFractionDowntime, + }, + }, + expectErr: false, + }, + } + + for _, tc := range testCases { + tc := tc + s.Run(tc.name, func() { + _, err := s.msgServer.UpdateParams(s.ctx, tc.request) + if tc.expectErr { + s.Require().Error(err) + s.Require().Contains(err.Error(), tc.expErrMsg) + } else { + s.Require().NoError(err) + } + }) + } +} diff --git a/x/slashing/keeper/params.go b/x/slashing/keeper/params.go index 8ece97a687ad..4c7fc1824694 100644 --- a/x/slashing/keeper/params.go +++ b/x/slashing/keeper/params.go @@ -9,46 +9,54 @@ import ( // SignedBlocksWindow - sliding window for downtime slashing func (k Keeper) SignedBlocksWindow(ctx sdk.Context) (res int64) { - k.paramspace.Get(ctx, types.KeySignedBlocksWindow, &res) - return + return k.GetParams(ctx).SignedBlocksWindow } // MinSignedPerWindow - minimum blocks signed per window func (k Keeper) MinSignedPerWindow(ctx sdk.Context) int64 { - var minSignedPerWindow sdk.Dec - k.paramspace.Get(ctx, types.KeyMinSignedPerWindow, &minSignedPerWindow) + params := k.GetParams(ctx) signedBlocksWindow := k.SignedBlocksWindow(ctx) // NOTE: RoundInt64 will never panic as minSignedPerWindow is // less than 1. - return minSignedPerWindow.MulInt64(signedBlocksWindow).RoundInt64() + return params.MinSignedPerWindow.MulInt64(signedBlocksWindow).RoundInt64() } // DowntimeJailDuration - Downtime unbond duration func (k Keeper) DowntimeJailDuration(ctx sdk.Context) (res time.Duration) { - k.paramspace.Get(ctx, types.KeyDowntimeJailDuration, &res) - return + return k.GetParams(ctx).DowntimeJailDuration } // SlashFractionDoubleSign - fraction of power slashed in case of double sign func (k Keeper) SlashFractionDoubleSign(ctx sdk.Context) (res sdk.Dec) { - k.paramspace.Get(ctx, types.KeySlashFractionDoubleSign, &res) - return + return k.GetParams(ctx).SlashFractionDoubleSign } // SlashFractionDowntime - fraction of power slashed for downtime func (k Keeper) SlashFractionDowntime(ctx sdk.Context) (res sdk.Dec) { - k.paramspace.Get(ctx, types.KeySlashFractionDowntime, &res) - return + return k.GetParams(ctx).SlashFractionDowntime } -// GetParams returns the total set of slashing parameters. +// GetParams returns the current x/slashing module parameters. func (k Keeper) GetParams(ctx sdk.Context) (params types.Params) { - k.paramspace.GetParamSet(ctx, ¶ms) + store := ctx.KVStore(k.storeKey) + bz := store.Get(types.ParamsKey) + if bz == nil { + return params + } + k.cdc.MustUnmarshal(bz, ¶ms) return params } -// SetParams sets the slashing parameters to the param space. -func (k Keeper) SetParams(ctx sdk.Context, params types.Params) { - k.paramspace.SetParamSet(ctx, ¶ms) +// SetParams sets the x/slashing module parameters. +func (k Keeper) SetParams(ctx sdk.Context, params types.Params) error { + if err := params.Validate(); err != nil { + return err + } + + store := ctx.KVStore(k.storeKey) + bz := k.cdc.MustMarshal(¶ms) + store.Set(types.ParamsKey, bz) + + return nil } diff --git a/x/slashing/keeper/params_test.go b/x/slashing/keeper/params_test.go new file mode 100644 index 000000000000..94faa023e0b1 --- /dev/null +++ b/x/slashing/keeper/params_test.go @@ -0,0 +1,119 @@ +package keeper_test + +import ( + "time" + + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/slashing/types" +) + +func (s *KeeperTestSuite) TestParams() { + minSignedPerWindow, err := sdk.NewDecFromStr("0.60") + s.Require().NoError(err) + + slashFractionDoubleSign, err := sdk.NewDecFromStr("0.022") + s.Require().NoError(err) + + slashFractionDowntime, err := sdk.NewDecFromStr("0.0089") + s.Require().NoError(err) + + invalidVal, err := sdk.NewDecFromStr("-1") + s.Require().NoError(err) + + testCases := []struct { + name string + input types.Params + expectErr bool + expErrMsg string + }{ + { + name: "set invalid signed blocks window", + input: types.Params{ + SignedBlocksWindow: 0, + MinSignedPerWindow: minSignedPerWindow, + DowntimeJailDuration: time.Duration(34800000000000), + SlashFractionDoubleSign: slashFractionDoubleSign, + SlashFractionDowntime: slashFractionDowntime, + }, + expectErr: true, + expErrMsg: "signed blocks window must be positive", + }, + { + name: "set invalid min signed per window", + input: types.Params{ + SignedBlocksWindow: int64(750), + MinSignedPerWindow: invalidVal, + DowntimeJailDuration: time.Duration(34800000000000), + SlashFractionDoubleSign: slashFractionDoubleSign, + SlashFractionDowntime: slashFractionDowntime, + }, + expectErr: true, + expErrMsg: "min signed per window cannot be negative", + }, + { + name: "set invalid downtime jail duration", + input: types.Params{ + SignedBlocksWindow: int64(750), + MinSignedPerWindow: minSignedPerWindow, + DowntimeJailDuration: time.Duration(0), + SlashFractionDoubleSign: slashFractionDoubleSign, + SlashFractionDowntime: slashFractionDowntime, + }, + expectErr: true, + expErrMsg: "downtime jail duration must be positive", + }, + { + name: "set invalid slash fraction double sign", + input: types.Params{ + SignedBlocksWindow: int64(750), + MinSignedPerWindow: minSignedPerWindow, + DowntimeJailDuration: time.Duration(10), + SlashFractionDoubleSign: invalidVal, + SlashFractionDowntime: slashFractionDowntime, + }, + expectErr: true, + expErrMsg: "double sign slash fraction cannot be negative", + }, + { + name: "set invalid slash fraction downtime", + input: types.Params{ + SignedBlocksWindow: int64(750), + MinSignedPerWindow: minSignedPerWindow, + DowntimeJailDuration: time.Duration(10), + SlashFractionDoubleSign: slashFractionDoubleSign, + SlashFractionDowntime: invalidVal, + }, + expectErr: true, + expErrMsg: "downtime slash fraction cannot be negative", + }, + { + name: "set all valid params", + input: types.Params{ + SignedBlocksWindow: int64(750), + MinSignedPerWindow: minSignedPerWindow, + DowntimeJailDuration: time.Duration(34800000000000), + SlashFractionDoubleSign: slashFractionDoubleSign, + SlashFractionDowntime: slashFractionDowntime, + }, + expectErr: false, + }, + } + for _, tc := range testCases { + tc := tc + s.Run(tc.name, func() { + expected := s.slashingKeeper.GetParams(s.ctx) + err := s.slashingKeeper.SetParams(s.ctx, tc.input) + + if tc.expectErr { + s.Require().Error(err) + s.Require().Contains(err.Error(), tc.expErrMsg) + } else { + expected = tc.input + s.Require().NoError(err) + } + + params := s.slashingKeeper.GetParams(s.ctx) + s.Require().Equal(expected, params) + }) + } +} diff --git a/x/slashing/migrations/v2/migrate.go b/x/slashing/migrations/v2/migrate.go new file mode 100644 index 000000000000..cd411b4c0929 --- /dev/null +++ b/x/slashing/migrations/v2/migrate.go @@ -0,0 +1,34 @@ +package v2 + +import ( + "github.com/cosmos/cosmos-sdk/codec" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/slashing/exported" + "github.com/cosmos/cosmos-sdk/x/slashing/types" +) + +const ( + ModuleName = "slashing" +) + +var ( + ParamsKey = []byte{0x00} +) + +// Migrate migrates the x/slashing module state from the consensus version 2 to +// version 3. Specifically, it takes the parameters that are currently stored +// and managed by the x/params modules and stores them directly into the x/slashing +// module state. +func Migrate(ctx sdk.Context, store sdk.KVStore, legacySubspace exported.Subspace, cdc codec.BinaryCodec) error { + var currParams types.Params + legacySubspace.GetParamSet(ctx, &currParams) + + if err := currParams.Validate(); err != nil { + return err + } + + bz := cdc.MustMarshal(&currParams) + store.Set(ParamsKey, bz) + + return nil +} diff --git a/x/slashing/migrations/v2/migrator_test.go b/x/slashing/migrations/v2/migrator_test.go new file mode 100644 index 000000000000..de0979b4036d --- /dev/null +++ b/x/slashing/migrations/v2/migrator_test.go @@ -0,0 +1,46 @@ +package v2_test + +import ( + "testing" + + "github.com/stretchr/testify/require" + + "github.com/cosmos/cosmos-sdk/testutil" + sdk "github.com/cosmos/cosmos-sdk/types" + + moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil" + "github.com/cosmos/cosmos-sdk/x/slashing" + "github.com/cosmos/cosmos-sdk/x/slashing/exported" + v2 "github.com/cosmos/cosmos-sdk/x/slashing/migrations/v2" + "github.com/cosmos/cosmos-sdk/x/slashing/types" +) + +type mockSubspace struct { + ps types.Params +} + +func newMockSubspace(ps types.Params) mockSubspace { + return mockSubspace{ps: ps} +} + +func (ms mockSubspace) GetParamSet(ctx sdk.Context, ps exported.ParamSet) { + *ps.(*types.Params) = ms.ps +} + +func TestMigrate(t *testing.T) { + encCfg := moduletestutil.MakeTestEncodingConfig(slashing.AppModuleBasic{}) + cdc := encCfg.Codec + + storeKey := sdk.NewKVStoreKey(v2.ModuleName) + tKey := sdk.NewTransientStoreKey("transient_test") + ctx := testutil.DefaultContext(storeKey, tKey) + store := ctx.KVStore(storeKey) + + legacySubspace := newMockSubspace(types.DefaultParams()) + require.NoError(t, v2.Migrate(ctx, store, legacySubspace, cdc)) + + var res types.Params + bz := store.Get(v2.ParamsKey) + require.NoError(t, cdc.Unmarshal(bz, &res)) + require.Equal(t, legacySubspace.ps, res) +} diff --git a/x/slashing/module.go b/x/slashing/module.go index 321cdba94ccf..a06c434b4992 100644 --- a/x/slashing/module.go +++ b/x/slashing/module.go @@ -20,16 +20,22 @@ import ( "github.com/cosmos/cosmos-sdk/depinject" "github.com/cosmos/cosmos-sdk/runtime" store "github.com/cosmos/cosmos-sdk/store/types" + govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" + sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/module" simtypes "github.com/cosmos/cosmos-sdk/types/simulation" - paramstypes "github.com/cosmos/cosmos-sdk/x/params/types" + authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" "github.com/cosmos/cosmos-sdk/x/slashing/client/cli" + "github.com/cosmos/cosmos-sdk/x/slashing/exported" "github.com/cosmos/cosmos-sdk/x/slashing/keeper" "github.com/cosmos/cosmos-sdk/x/slashing/simulation" "github.com/cosmos/cosmos-sdk/x/slashing/types" ) +// ConsensusVersion defines the current x/slashing module consensus version. +const ConsensusVersion = 3 + var ( _ module.AppModule = AppModule{} _ module.AppModuleBasic = AppModuleBasic{} @@ -99,16 +105,20 @@ type AppModule struct { accountKeeper types.AccountKeeper bankKeeper types.BankKeeper stakingKeeper types.StakingKeeper + + // legacySubspace is used solely for migration of x/slashing managed parameters + legacySubspace exported.Subspace } // NewAppModule creates a new AppModule object -func NewAppModule(cdc codec.Codec, keeper keeper.Keeper, ak types.AccountKeeper, bk types.BankKeeper, sk types.StakingKeeper) AppModule { +func NewAppModule(cdc codec.Codec, keeper keeper.Keeper, ak types.AccountKeeper, bk types.BankKeeper, sk types.StakingKeeper, ss exported.Subspace) AppModule { return AppModule{ AppModuleBasic: AppModuleBasic{cdc: cdc}, keeper: keeper, accountKeeper: ak, bankKeeper: bk, stakingKeeper: sk, + legacySubspace: ss, } } @@ -140,8 +150,14 @@ func (am AppModule) RegisterServices(cfg module.Configurator) { types.RegisterMsgServer(cfg.MsgServer(), keeper.NewMsgServerImpl(am.keeper)) types.RegisterQueryServer(cfg.QueryServer(), am.keeper) - m := keeper.NewMigrator(am.keeper) - cfg.RegisterMigration(types.ModuleName, 1, m.Migrate1to2) + m := keeper.NewMigrator(am.keeper, am.legacySubspace) + if err := cfg.RegisterMigration(types.ModuleName, 1, m.Migrate1to2); err != nil { + panic(fmt.Sprintf("failed to migrate x/%s from version 1 to 2: %v", types.ModuleName, err)) + } + + if err := cfg.RegisterMigration(types.ModuleName, 2, m.Migrate2to3); err != nil { + panic(fmt.Sprintf("failed to migrate x/%s from version 2 to 3: %v", types.ModuleName, err)) + } } // InitGenesis performs genesis initialization for the slashing module. It returns @@ -161,7 +177,7 @@ func (am AppModule) ExportGenesis(ctx sdk.Context, cdc codec.JSONCodec) json.Raw } // ConsensusVersion implements AppModule/ConsensusVersion. -func (AppModule) ConsensusVersion() uint64 { return 2 } +func (AppModule) ConsensusVersion() uint64 { return ConsensusVersion } // BeginBlock returns the begin blocker for the slashing module. func (am AppModule) BeginBlock(ctx sdk.Context, req abci.RequestBeginBlock) { @@ -195,10 +211,13 @@ type slashingInputs struct { Key *store.KVStoreKey Cdc codec.Codec - AccountKeeper types.AccountKeeper - BankKeeper types.BankKeeper - StakingKeeper types.StakingKeeper - Subspace paramstypes.Subspace + LegacyAmino *codec.LegacyAmino + AccountKeeper types.AccountKeeper `key:"cosmos.auth.v1.AccountKeeper"` + BankKeeper types.BankKeeper `key:"cosmos.bank.v1.Keeper"` + StakingKeeper types.StakingKeeper `key:"cosmos.staking.v1.Keeper"` + + // LegacySubspace is used solely for migration of x/params managed parameters + LegacySubspace exported.Subspace } type slashingOutputs struct { @@ -210,8 +229,8 @@ type slashingOutputs struct { } func provideModule(in slashingInputs) slashingOutputs { - k := keeper.NewKeeper(in.Cdc, in.Key, in.StakingKeeper, in.Subspace) - m := NewAppModule(in.Cdc, k, in.AccountKeeper, in.BankKeeper, in.StakingKeeper) + k := keeper.NewKeeper(in.Cdc, in.LegacyAmino, in.Key, in.StakingKeeper, authtypes.NewModuleAddress(govtypes.ModuleName).String()) + m := NewAppModule(in.Cdc, k, in.AccountKeeper, in.BankKeeper, in.StakingKeeper, in.LegacySubspace) return slashingOutputs{ Keeper: k, Module: runtime.WrapAppModule(m), @@ -235,7 +254,7 @@ func (AppModule) ProposalContents(simState module.SimulationState) []simtypes.We // RandomizedParams creates randomized slashing param changes for the simulator. func (AppModule) RandomizedParams(r *rand.Rand) []simtypes.ParamChange { - return simulation.ParamChanges(r) + return []simtypes.ParamChange{} } // RegisterStoreDecoder registers a decoder for slashing module's types diff --git a/x/slashing/types/codec.go b/x/slashing/types/codec.go index d1b54a969ee1..35af62c22632 100644 --- a/x/slashing/types/codec.go +++ b/x/slashing/types/codec.go @@ -12,12 +12,15 @@ import ( // RegisterLegacyAminoCodec registers concrete types on LegacyAmino codec func RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) { + cdc.RegisterConcrete(Params{}, "cosmos-sdk/x/slashing/Params", nil) legacy.RegisterAminoMsg(cdc, &MsgUnjail{}, "cosmos-sdk/MsgUnjail") + legacy.RegisterAminoMsg(cdc, &MsgUpdateParams{}, "cosmos-sdk/MsgUpdateParams") } func RegisterInterfaces(registry types.InterfaceRegistry) { registry.RegisterImplementations((*sdk.Msg)(nil), &MsgUnjail{}, + &MsgUpdateParams{}, ) msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc) diff --git a/x/slashing/types/genesis.pb.go b/x/slashing/types/genesis.pb.go index 43240e134db5..43ad7925d509 100644 --- a/x/slashing/types/genesis.pb.go +++ b/x/slashing/types/genesis.pb.go @@ -26,7 +26,7 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package // GenesisState defines the slashing module's genesis state. type GenesisState struct { - // params defines all the paramaters of related to deposit. + // params defines all the parameters of the module. Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"` // signing_infos represents a map between validator addresses and their // signing infos. diff --git a/x/slashing/types/keys.go b/x/slashing/types/keys.go index 09c978c9a4d5..bf4c1bc75852 100644 --- a/x/slashing/types/keys.go +++ b/x/slashing/types/keys.go @@ -30,7 +30,9 @@ const ( // - 0x02: bool // // - 0x03: cryptotypes.PubKey + var ( + ParamsKey = []byte{0x00} // Prefix for params key ValidatorSigningInfoKeyPrefix = []byte{0x01} // Prefix for signing info ValidatorMissedBlockBitArrayKeyPrefix = []byte{0x02} // Prefix for missed block bit array AddrPubkeyRelationKeyPrefix = []byte{0x03} // Prefix for address-pubkey relation diff --git a/x/slashing/types/msg.go b/x/slashing/types/msg.go index e5e0ec0f24f2..a4b893708153 100644 --- a/x/slashing/types/msg.go +++ b/x/slashing/types/msg.go @@ -11,7 +11,10 @@ const ( ) // verify interface at compile time -var _ sdk.Msg = &MsgUnjail{} +var ( + _ sdk.Msg = &MsgUnjail{} + _ sdk.Msg = &MsgUpdateParams{} +) // NewMsgUnjail creates a new MsgUnjail instance //nolint:interfacer @@ -41,3 +44,27 @@ func (msg MsgUnjail) ValidateBasic() error { } return nil } + +// GetSignBytes implements the LegacyMsg interface. +func (msg MsgUpdateParams) GetSignBytes() []byte { + return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&msg)) +} + +// GetSigners returns the expected signers for a MsgUpdateParams message. +func (msg *MsgUpdateParams) GetSigners() []sdk.AccAddress { + addr, _ := sdk.AccAddressFromBech32(msg.Authority) + return []sdk.AccAddress{addr} +} + +// ValidateBasic does a sanity check on the provided data. +func (msg *MsgUpdateParams) ValidateBasic() error { + if _, err := sdk.AccAddressFromBech32(msg.Authority); err != nil { + return sdkerrors.Wrap(err, "invalid authority address") + } + + if err := msg.Params.Validate(); err != nil { + return err + } + + return nil +} diff --git a/x/slashing/types/params.go b/x/slashing/types/params.go index ad1d98c37f15..e93cad293f0c 100644 --- a/x/slashing/types/params.go +++ b/x/slashing/types/params.go @@ -5,7 +5,6 @@ import ( "time" sdk "github.com/cosmos/cosmos-sdk/types" - paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" ) // Default parameter namespace @@ -20,20 +19,6 @@ var ( DefaultSlashFractionDowntime = sdk.NewDec(1).Quo(sdk.NewDec(100)) ) -// Parameter store keys -var ( - KeySignedBlocksWindow = []byte("SignedBlocksWindow") - KeyMinSignedPerWindow = []byte("MinSignedPerWindow") - KeyDowntimeJailDuration = []byte("DowntimeJailDuration") - KeySlashFractionDoubleSign = []byte("SlashFractionDoubleSign") - KeySlashFractionDowntime = []byte("SlashFractionDowntime") -) - -// ParamKeyTable for slashing module -func ParamKeyTable() paramtypes.KeyTable { - return paramtypes.NewKeyTable().RegisterParamSet(&Params{}) -} - // NewParams creates a new Params object func NewParams( signedBlocksWindow int64, minSignedPerWindow sdk.Dec, downtimeJailDuration time.Duration, @@ -48,25 +33,37 @@ func NewParams( } } -// ParamSetPairs - Implements params.ParamSet -func (p *Params) ParamSetPairs() paramtypes.ParamSetPairs { - return paramtypes.ParamSetPairs{ - paramtypes.NewParamSetPair(KeySignedBlocksWindow, &p.SignedBlocksWindow, validateSignedBlocksWindow), - paramtypes.NewParamSetPair(KeyMinSignedPerWindow, &p.MinSignedPerWindow, validateMinSignedPerWindow), - paramtypes.NewParamSetPair(KeyDowntimeJailDuration, &p.DowntimeJailDuration, validateDowntimeJailDuration), - paramtypes.NewParamSetPair(KeySlashFractionDoubleSign, &p.SlashFractionDoubleSign, validateSlashFractionDoubleSign), - paramtypes.NewParamSetPair(KeySlashFractionDowntime, &p.SlashFractionDowntime, validateSlashFractionDowntime), - } -} - // DefaultParams defines the parameters for this module func DefaultParams() Params { return NewParams( - DefaultSignedBlocksWindow, DefaultMinSignedPerWindow, DefaultDowntimeJailDuration, - DefaultSlashFractionDoubleSign, DefaultSlashFractionDowntime, + DefaultSignedBlocksWindow, + DefaultMinSignedPerWindow, + DefaultDowntimeJailDuration, + DefaultSlashFractionDoubleSign, + DefaultSlashFractionDowntime, ) } +// validate params +func (p Params) Validate() error { + if err := validateSignedBlocksWindow(p.SignedBlocksWindow); err != nil { + return err + } + if err := validateMinSignedPerWindow(p.MinSignedPerWindow); err != nil { + return err + } + if err := validateDowntimeJailDuration(p.DowntimeJailDuration); err != nil { + return err + } + if err := validateSlashFractionDoubleSign(p.SlashFractionDoubleSign); err != nil { + return err + } + if err := validateSlashFractionDowntime(p.SlashFractionDowntime); err != nil { + return err + } + return nil +} + func validateSignedBlocksWindow(i interface{}) error { v, ok := i.(int64) if !ok { diff --git a/x/slashing/types/params_legacy.go b/x/slashing/types/params_legacy.go new file mode 100644 index 000000000000..15bb92159596 --- /dev/null +++ b/x/slashing/types/params_legacy.go @@ -0,0 +1,39 @@ +/* +NOTE: Usage of x/params to manage parameters is deprecated in favor of x/gov +controlled execution of MsgUpdateParams messages. These types remains solely +for migration purposes and will be removed in a future release. +*/ +package types + +import ( + paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" +) + +// Parameter store keys +var ( + KeySignedBlocksWindow = []byte("SignedBlocksWindow") + KeyMinSignedPerWindow = []byte("MinSignedPerWindow") + KeyDowntimeJailDuration = []byte("DowntimeJailDuration") + KeySlashFractionDoubleSign = []byte("SlashFractionDoubleSign") + KeySlashFractionDowntime = []byte("SlashFractionDowntime") +) + +// ParamKeyTable for slashing module +// +// NOTE: Deprecated. +func ParamKeyTable() paramtypes.KeyTable { + return paramtypes.NewKeyTable().RegisterParamSet(&Params{}) +} + +// ParamSetPairs - Implements params.ParamSet +// +// NOTE: Deprecated. +func (p *Params) ParamSetPairs() paramtypes.ParamSetPairs { + return paramtypes.ParamSetPairs{ + paramtypes.NewParamSetPair(KeySignedBlocksWindow, &p.SignedBlocksWindow, validateSignedBlocksWindow), + paramtypes.NewParamSetPair(KeyMinSignedPerWindow, &p.MinSignedPerWindow, validateMinSignedPerWindow), + paramtypes.NewParamSetPair(KeyDowntimeJailDuration, &p.DowntimeJailDuration, validateDowntimeJailDuration), + paramtypes.NewParamSetPair(KeySlashFractionDoubleSign, &p.SlashFractionDoubleSign, validateSlashFractionDoubleSign), + paramtypes.NewParamSetPair(KeySlashFractionDowntime, &p.SlashFractionDowntime, validateSlashFractionDowntime), + } +} diff --git a/x/slashing/types/tx.pb.go b/x/slashing/types/tx.pb.go index 0ecb663dc21f..6450dc0e98d0 100644 --- a/x/slashing/types/tx.pb.go +++ b/x/slashing/types/tx.pb.go @@ -105,34 +105,142 @@ func (m *MsgUnjailResponse) XXX_DiscardUnknown() { var xxx_messageInfo_MsgUnjailResponse proto.InternalMessageInfo +// MsgUpdateParams is the Msg/UpdateParams request type. +// +// Since: cosmos-sdk 0.47 +type MsgUpdateParams struct { + // authority is the address of the governance account. + Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"` + // params defines the x/slashing parameters to update. + // + // NOTE: All parameters must be supplied. + Params Params `protobuf:"bytes,2,opt,name=params,proto3" json:"params"` +} + +func (m *MsgUpdateParams) Reset() { *m = MsgUpdateParams{} } +func (m *MsgUpdateParams) String() string { return proto.CompactTextString(m) } +func (*MsgUpdateParams) ProtoMessage() {} +func (*MsgUpdateParams) Descriptor() ([]byte, []int) { + return fileDescriptor_3c5611c0c4a59d9d, []int{2} +} +func (m *MsgUpdateParams) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgUpdateParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgUpdateParams.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *MsgUpdateParams) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgUpdateParams.Merge(m, src) +} +func (m *MsgUpdateParams) XXX_Size() int { + return m.Size() +} +func (m *MsgUpdateParams) XXX_DiscardUnknown() { + xxx_messageInfo_MsgUpdateParams.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgUpdateParams proto.InternalMessageInfo + +func (m *MsgUpdateParams) GetAuthority() string { + if m != nil { + return m.Authority + } + return "" +} + +func (m *MsgUpdateParams) GetParams() Params { + if m != nil { + return m.Params + } + return Params{} +} + +// MsgUpdateParamsResponse defines the response structure for executing a +// MsgUpdateParams message. +// +// Since: cosmos-sdk 0.47 +type MsgUpdateParamsResponse struct { +} + +func (m *MsgUpdateParamsResponse) Reset() { *m = MsgUpdateParamsResponse{} } +func (m *MsgUpdateParamsResponse) String() string { return proto.CompactTextString(m) } +func (*MsgUpdateParamsResponse) ProtoMessage() {} +func (*MsgUpdateParamsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_3c5611c0c4a59d9d, []int{3} +} +func (m *MsgUpdateParamsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgUpdateParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgUpdateParamsResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *MsgUpdateParamsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgUpdateParamsResponse.Merge(m, src) +} +func (m *MsgUpdateParamsResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgUpdateParamsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgUpdateParamsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgUpdateParamsResponse proto.InternalMessageInfo + func init() { proto.RegisterType((*MsgUnjail)(nil), "cosmos.slashing.v1beta1.MsgUnjail") proto.RegisterType((*MsgUnjailResponse)(nil), "cosmos.slashing.v1beta1.MsgUnjailResponse") + proto.RegisterType((*MsgUpdateParams)(nil), "cosmos.slashing.v1beta1.MsgUpdateParams") + proto.RegisterType((*MsgUpdateParamsResponse)(nil), "cosmos.slashing.v1beta1.MsgUpdateParamsResponse") } func init() { proto.RegisterFile("cosmos/slashing/v1beta1/tx.proto", fileDescriptor_3c5611c0c4a59d9d) } var fileDescriptor_3c5611c0c4a59d9d = []byte{ - // 296 bytes of a gzipped FileDescriptorProto + // 407 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x48, 0xce, 0x2f, 0xce, 0xcd, 0x2f, 0xd6, 0x2f, 0xce, 0x49, 0x2c, 0xce, 0xc8, 0xcc, 0x4b, 0xd7, 0x2f, 0x33, 0x4c, 0x4a, 0x2d, 0x49, 0x34, 0xd4, 0x2f, 0xa9, 0xd0, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x87, 0xa8, 0xd0, 0x83, 0xa9, 0xd0, 0x83, 0xaa, 0x90, 0x12, 0x49, 0xcf, 0x4f, 0xcf, 0x07, 0xab, 0xd1, 0x07, - 0xb1, 0x20, 0xca, 0xa5, 0x24, 0x21, 0xca, 0xe3, 0x21, 0x12, 0x50, 0xbd, 0x10, 0x29, 0xa8, 0x49, - 0xfa, 0xb9, 0xc5, 0x20, 0x6b, 0x40, 0x14, 0x44, 0x42, 0xa9, 0x84, 0x8b, 0xd3, 0xb7, 0x38, 0x3d, - 0x34, 0x2f, 0x2b, 0x31, 0x33, 0x47, 0xc8, 0x8b, 0x8b, 0xaf, 0x2c, 0x31, 0x27, 0x33, 0x25, 0xb1, - 0x24, 0xbf, 0x28, 0x3e, 0x31, 0x25, 0xa5, 0x48, 0x82, 0x51, 0x81, 0x51, 0x83, 0xd3, 0x49, 0xf9, - 0xd5, 0x3d, 0x79, 0x76, 0x10, 0x3f, 0xb5, 0xb8, 0xf8, 0xd2, 0x16, 0x5d, 0x11, 0xa8, 0xd1, 0x8e, - 0x10, 0x91, 0xe0, 0x92, 0xa2, 0xcc, 0xbc, 0xf4, 0x20, 0x5e, 0xb8, 0x56, 0x90, 0xb8, 0x95, 0x74, - 0xc7, 0x02, 0x79, 0x86, 0x19, 0x0b, 0xe4, 0x19, 0x9b, 0x9e, 0x6f, 0xd0, 0x42, 0x33, 0x56, 0x49, - 0x98, 0x4b, 0x10, 0x6e, 0x6b, 0x50, 0x6a, 0x71, 0x41, 0x7e, 0x5e, 0x71, 0xaa, 0x51, 0x3c, 0x17, - 0xb3, 0x6f, 0x71, 0xba, 0x50, 0x04, 0x17, 0x1b, 0xd4, 0x39, 0x4a, 0x7a, 0x38, 0xfc, 0xaf, 0x07, - 0xd7, 0x2c, 0xa5, 0x45, 0x58, 0x0d, 0xcc, 0x02, 0x27, 0xef, 0x15, 0x8f, 0xe4, 0x18, 0x4f, 0x3c, - 0x92, 0x63, 0xbc, 0xf0, 0x48, 0x8e, 0xf1, 0xc1, 0x23, 0x39, 0xc6, 0x09, 0x8f, 0xe5, 0x18, 0x2e, - 0x3c, 0x96, 0x63, 0xb8, 0xf1, 0x58, 0x8e, 0x21, 0x4a, 0x37, 0x3d, 0xb3, 0x24, 0xa3, 0x34, 0x49, - 0x2f, 0x39, 0x3f, 0x17, 0x1a, 0x76, 0x50, 0x4a, 0xb7, 0x38, 0x25, 0x5b, 0xbf, 0x02, 0x11, 0x4d, - 0x25, 0x95, 0x05, 0xa9, 0xc5, 0x49, 0x6c, 0xe0, 0xf0, 0x33, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, - 0xc5, 0xe4, 0xf3, 0x05, 0xc6, 0x01, 0x00, 0x00, + 0xb1, 0x20, 0xca, 0xa5, 0xd4, 0x70, 0x19, 0x08, 0xd7, 0x0f, 0x51, 0x27, 0x09, 0x51, 0x17, 0x0f, + 0x31, 0x00, 0x6a, 0x07, 0x44, 0x0a, 0x6a, 0xa3, 0x7e, 0x6e, 0x31, 0x48, 0x37, 0x88, 0x82, 0x48, + 0x28, 0x95, 0x70, 0x71, 0xfa, 0x16, 0xa7, 0x87, 0xe6, 0x65, 0x25, 0x66, 0xe6, 0x08, 0x79, 0x71, + 0xf1, 0x95, 0x25, 0xe6, 0x64, 0xa6, 0x24, 0x96, 0xe4, 0x17, 0xc5, 0x27, 0xa6, 0xa4, 0x14, 0x49, + 0x30, 0x2a, 0x30, 0x6a, 0x70, 0x3a, 0x29, 0xbf, 0xba, 0x27, 0xcf, 0x0e, 0xe2, 0xa7, 0x16, 0x17, + 0x5f, 0xda, 0xa2, 0x2b, 0x02, 0x35, 0xda, 0x11, 0x22, 0x12, 0x5c, 0x52, 0x94, 0x99, 0x97, 0x1e, + 0xc4, 0x0b, 0xd7, 0x0a, 0x12, 0xb7, 0x92, 0xee, 0x58, 0x20, 0xcf, 0x30, 0x63, 0x81, 0x3c, 0x63, + 0xd3, 0xf3, 0x0d, 0x5a, 0x68, 0xc6, 0x2a, 0x09, 0x73, 0x09, 0xc2, 0x6d, 0x0d, 0x4a, 0x2d, 0x2e, + 0xc8, 0xcf, 0x2b, 0x4e, 0x55, 0x9a, 0xc1, 0xc8, 0xc5, 0x0f, 0x12, 0x2d, 0x48, 0x49, 0x2c, 0x49, + 0x0d, 0x48, 0x2c, 0x4a, 0xcc, 0x2d, 0x16, 0x32, 0xe3, 0xe2, 0x4c, 0x2c, 0x2d, 0xc9, 0xc8, 0x2f, + 0xca, 0x2c, 0xa9, 0x84, 0x3a, 0x46, 0x02, 0xa7, 0x0b, 0x10, 0x4a, 0x85, 0x6c, 0xb9, 0xd8, 0x0a, + 0xc0, 0x26, 0x48, 0x30, 0x29, 0x30, 0x6a, 0x70, 0x1b, 0xc9, 0xeb, 0xe1, 0x08, 0x72, 0x3d, 0x88, + 0x45, 0x4e, 0x2c, 0x27, 0xee, 0xc9, 0x33, 0x04, 0x41, 0x35, 0x59, 0xf1, 0x81, 0x1c, 0x8d, 0x30, + 0x4e, 0x49, 0x92, 0x4b, 0x1c, 0xcd, 0x65, 0x30, 0x57, 0x1b, 0x9d, 0x66, 0xe4, 0x62, 0xf6, 0x2d, + 0x4e, 0x17, 0x8a, 0xe0, 0x62, 0x83, 0x86, 0xa2, 0x12, 0x4e, 0xbb, 0xe0, 0x7e, 0x96, 0xd2, 0x22, + 0xac, 0x06, 0x66, 0x83, 0x50, 0x16, 0x17, 0x0f, 0x4a, 0x98, 0x68, 0xe0, 0xd5, 0x8b, 0xa4, 0x52, + 0xca, 0x80, 0x58, 0x95, 0x30, 0xbb, 0x9c, 0xbc, 0x57, 0x3c, 0x92, 0x63, 0x3c, 0xf1, 0x48, 0x8e, + 0xf1, 0xc2, 0x23, 0x39, 0xc6, 0x07, 0x8f, 0xe4, 0x18, 0x27, 0x3c, 0x96, 0x63, 0xb8, 0xf0, 0x58, + 0x8e, 0xe1, 0xc6, 0x63, 0x39, 0x86, 0x28, 0xdd, 0xf4, 0xcc, 0x92, 0x8c, 0xd2, 0x24, 0xbd, 0xe4, + 0xfc, 0x5c, 0x68, 0xf2, 0x82, 0x52, 0xba, 0xc5, 0x29, 0xd9, 0xfa, 0x15, 0x88, 0x04, 0x5a, 0x52, + 0x59, 0x90, 0x5a, 0x9c, 0xc4, 0x06, 0x4e, 0x62, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x61, + 0xd5, 0x7a, 0xbc, 0x11, 0x03, 0x00, 0x00, } func (this *MsgUnjail) Equal(that interface{}) bool { @@ -180,6 +288,54 @@ func (this *MsgUnjailResponse) Equal(that interface{}) bool { } return true } +func (this *MsgUpdateParams) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*MsgUpdateParams) + if !ok { + that2, ok := that.(MsgUpdateParams) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if this.Authority != that1.Authority { + return false + } + if !this.Params.Equal(&that1.Params) { + return false + } + return true +} +func (this *MsgUpdateParamsResponse) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*MsgUpdateParamsResponse) + if !ok { + that2, ok := that.(MsgUpdateParamsResponse) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + return true +} // Reference imports to suppress errors if they are not otherwise used. var _ context.Context @@ -197,6 +353,11 @@ type MsgClient interface { // them into the bonded validator set, so they can begin receiving provisions // and rewards again. Unjail(ctx context.Context, in *MsgUnjail, opts ...grpc.CallOption) (*MsgUnjailResponse, error) + // UpdateParams defines a governance operation for updating the x/slashing module + // parameters. The authority is hard-coded to the x/gov module account. + // + // Since: cosmos-sdk 0.47 + UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) } type msgClient struct { @@ -216,12 +377,26 @@ func (c *msgClient) Unjail(ctx context.Context, in *MsgUnjail, opts ...grpc.Call return out, nil } +func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) { + out := new(MsgUpdateParamsResponse) + err := c.cc.Invoke(ctx, "/cosmos.slashing.v1beta1.Msg/UpdateParams", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // MsgServer is the server API for Msg service. type MsgServer interface { // Unjail defines a method for unjailing a jailed validator, thus returning // them into the bonded validator set, so they can begin receiving provisions // and rewards again. Unjail(context.Context, *MsgUnjail) (*MsgUnjailResponse, error) + // UpdateParams defines a governance operation for updating the x/slashing module + // parameters. The authority is hard-coded to the x/gov module account. + // + // Since: cosmos-sdk 0.47 + UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error) } // UnimplementedMsgServer can be embedded to have forward compatible implementations. @@ -231,6 +406,9 @@ type UnimplementedMsgServer struct { func (*UnimplementedMsgServer) Unjail(ctx context.Context, req *MsgUnjail) (*MsgUnjailResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Unjail not implemented") } +func (*UnimplementedMsgServer) UpdateParams(ctx context.Context, req *MsgUpdateParams) (*MsgUpdateParamsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateParams not implemented") +} func RegisterMsgServer(s grpc1.Server, srv MsgServer) { s.RegisterService(&_Msg_serviceDesc, srv) @@ -254,6 +432,24 @@ func _Msg_Unjail_Handler(srv interface{}, ctx context.Context, dec func(interfac return interceptor(ctx, in, info, handler) } +func _Msg_UpdateParams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgUpdateParams) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).UpdateParams(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmos.slashing.v1beta1.Msg/UpdateParams", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).UpdateParams(ctx, req.(*MsgUpdateParams)) + } + return interceptor(ctx, in, info, handler) +} + var _Msg_serviceDesc = grpc.ServiceDesc{ ServiceName: "cosmos.slashing.v1beta1.Msg", HandlerType: (*MsgServer)(nil), @@ -262,6 +458,10 @@ var _Msg_serviceDesc = grpc.ServiceDesc{ MethodName: "Unjail", Handler: _Msg_Unjail_Handler, }, + { + MethodName: "UpdateParams", + Handler: _Msg_UpdateParams_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "cosmos/slashing/v1beta1/tx.proto", @@ -320,6 +520,69 @@ func (m *MsgUnjailResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *MsgUpdateParams) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgUpdateParams) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgUpdateParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Params.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + if len(m.Authority) > 0 { + i -= len(m.Authority) + copy(dAtA[i:], m.Authority) + i = encodeVarintTx(dAtA, i, uint64(len(m.Authority))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgUpdateParamsResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgUpdateParamsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgUpdateParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + func encodeVarintTx(dAtA []byte, offset int, v uint64) int { offset -= sovTx(v) base := offset @@ -353,6 +616,30 @@ func (m *MsgUnjailResponse) Size() (n int) { return n } +func (m *MsgUpdateParams) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Authority) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = m.Params.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgUpdateParamsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + func sovTx(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } @@ -491,6 +778,171 @@ func (m *MsgUnjailResponse) Unmarshal(dAtA []byte) error { } return nil } +func (m *MsgUpdateParams) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgUpdateParams: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgUpdateParams: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Authority = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgUpdateParamsResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgUpdateParamsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgUpdateParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipTx(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 From 18da0e9c15e0210fdd289e3f1f0f5fefe3f6b72a Mon Sep 17 00:00:00 2001 From: Tyler <48813565+technicallyty@users.noreply.github.com> Date: Thu, 7 Jul 2022 09:42:24 -0700 Subject: [PATCH 04/37] fix(x/auth): allow multiple = signs in `GetTxsEvent` (#12474) --- CHANGELOG.md | 1 + x/auth/tx/service.go | 12 +++++-- x/auth/tx/service_test.go | 75 +++++++++++++++++++++++++++++++++++++++ 3 files changed, 85 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 7c46e3cb1eeb..71f9e0cb213e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -88,6 +88,7 @@ Ref: https://keepachangelog.com/en/1.0.0/ * (x/staking) [#12303](https://github.com/cosmos/cosmos-sdk/pull/12303) Use bytes instead of string comparison in delete validator queue * (testutil/sims) [#12374](https://github.com/cosmos/cosmos-sdk/pull/12374) fix the non-determinstic behavior in simulations caused by `GenSignedMockTx` and check empty coins slice before it is used to create `banktype.MsgSend`. +* (x/auth/tx) [#12474](https://github.com/cosmos/cosmos-sdk/pull/12474) Remove condition in GetTxsEvent that disallowed multiple equal signs, which would break event queries with base64 strings (i.e. query by signature). ## [v0.46.0-rc1](https://github.com/cosmos/cosmos-sdk/releases/tag/v0.46.0-rc1) - 2022-05-23 diff --git a/x/auth/tx/service.go b/x/auth/tx/service.go index d86e952f7b46..fe23c487e82c 100644 --- a/x/auth/tx/service.go +++ b/x/auth/tx/service.go @@ -3,6 +3,7 @@ package tx import ( "context" "fmt" + "regexp" "strings" gogogrpc "github.com/gogo/protobuf/grpc" @@ -39,13 +40,18 @@ func NewTxServer(clientCtx client.Context, simulate baseAppSimulateFn, interface } } -var _ txtypes.ServiceServer = txServer{} +var ( + _ txtypes.ServiceServer = txServer{} + + // EventRegex checks that an event string is formatted with {alphabetic}.{alphabetic}={value} + EventRegex = regexp.MustCompile(`^[a-zA-Z]+\.[a-zA-Z]+=\S+$`) +) const ( eventFormat = "{eventType}.{eventAttribute}={value}" ) -// TxsByEvents implements the ServiceServer.TxsByEvents RPC method. +// GetTxsEvent implements the ServiceServer.TxsByEvents RPC method. func (s txServer) GetTxsEvent(ctx context.Context, req *txtypes.GetTxsEventRequest) (*txtypes.GetTxsEventResponse, error) { if req == nil { return nil, status.Error(codes.InvalidArgument, "request cannot be nil") @@ -69,7 +75,7 @@ func (s txServer) GetTxsEvent(ctx context.Context, req *txtypes.GetTxsEventReque } for _, event := range req.Events { - if !strings.Contains(event, "=") || strings.Count(event, "=") > 1 { + if !EventRegex.Match([]byte(event)) { return nil, status.Error(codes.InvalidArgument, fmt.Sprintf("invalid event; event %s should be of the format: %s", event, eventFormat)) } } diff --git a/x/auth/tx/service_test.go b/x/auth/tx/service_test.go index fa0b59152d42..23412fc67aca 100644 --- a/x/auth/tx/service_test.go +++ b/x/auth/tx/service_test.go @@ -4,10 +4,12 @@ package tx_test import ( "context" + "encoding/base64" "fmt" "strings" "testing" + "github.com/stretchr/testify/require" "github.com/stretchr/testify/suite" "github.com/cosmos/cosmos-sdk/client" @@ -28,6 +30,7 @@ import ( "github.com/cosmos/cosmos-sdk/types/tx/signing" authclient "github.com/cosmos/cosmos-sdk/x/auth/client" authtest "github.com/cosmos/cosmos-sdk/x/auth/client/testutil" + authtx "github.com/cosmos/cosmos-sdk/x/auth/tx" bankcli "github.com/cosmos/cosmos-sdk/x/bank/client/testutil" banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" ) @@ -111,6 +114,78 @@ func (s *IntegrationTestSuite) TearDownSuite() { s.network.Cleanup() } +func (s *IntegrationTestSuite) TestQueryBySig() { + // broadcast tx + txb := s.mkTxBuilder() + txbz, err := s.cfg.TxConfig.TxEncoder()(txb.GetTx()) + s.Require().NoError(err) + _, err = s.queryClient.BroadcastTx(context.Background(), &tx.BroadcastTxRequest{TxBytes: txbz, Mode: tx.BroadcastMode_BROADCAST_MODE_BLOCK}) + s.Require().NoError(err) + + // get the signature out of the builder + sigs, err := txb.GetTx().GetSignaturesV2() + s.Require().NoError(err) + s.Require().Len(sigs, 1) + sig, ok := sigs[0].Data.(*signing.SingleSignatureData) + s.Require().True(ok) + + // encode, format, query + b64Sig := base64.StdEncoding.EncodeToString(sig.Signature) + sigFormatted := fmt.Sprintf("%s.%s='%s'", sdk.EventTypeTx, sdk.AttributeKeySignature, b64Sig) + res, err := s.queryClient.GetTxsEvent(context.Background(), &tx.GetTxsEventRequest{ + Events: []string{sigFormatted}, + OrderBy: 0, + Page: 0, + Limit: 10, + }) + s.Require().NoError(err) + s.Require().Len(res.Txs, 1) + s.Require().Len(res.Txs[0].Signatures, 1) + s.Require().Equal(res.Txs[0].Signatures[0], sig.Signature) + + // bad format should error + _, err = s.queryClient.GetTxsEvent(context.Background(), &tx.GetTxsEventRequest{Events: []string{"tx.foo.bar='baz'"}}) + s.Require().ErrorContains(err, "invalid event;") +} + +func TestEventRegex(t *testing.T) { + t.Parallel() + + testCases := []struct { + name string + event string + match bool + }{ + { + name: "valid: with quotes", + event: "tx.message='something'", + match: true, + }, + { + name: "valid: no quotes", + event: "tx.message=something", + match: true, + }, + { + name: "invalid: too many separators", + event: "tx.message.foo='bar'", + match: false, + }, + { + name: "valid: symbols ok", + event: "tx.signature='foobar/baz123=='", + match: true, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + match := authtx.EventRegex.Match([]byte(tc.event)) + require.Equal(t, tc.match, match) + }) + } +} + func (s IntegrationTestSuite) TestSimulateTx_GRPC() { val := s.network.Validators[0] txBuilder := s.mkTxBuilder() From 9057db6ec8f10dab96e478e6c52eb877a496284b Mon Sep 17 00:00:00 2001 From: Robert Zaremba Date: Thu, 7 Jul 2022 19:41:19 +0200 Subject: [PATCH 05/37] fix(telemetry): start telemetry independently from the API server (#12448) * fix(telemetry): start telemetry independently from the API server * fix unlock * add changelog * Update CHANGELOG.md Co-authored-by: Aleksandr Bezobchuk Co-authored-by: Aleksandr Bezobchuk --- CHANGELOG.md | 1 + server/api/server.go | 22 +++++++++------------- server/start.go | 21 +++++++++++++++++++++ 3 files changed, 31 insertions(+), 13 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 71f9e0cb213e..6174a6eda918 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -89,6 +89,7 @@ Ref: https://keepachangelog.com/en/1.0.0/ * (testutil/sims) [#12374](https://github.com/cosmos/cosmos-sdk/pull/12374) fix the non-determinstic behavior in simulations caused by `GenSignedMockTx` and check empty coins slice before it is used to create `banktype.MsgSend`. * (x/auth/tx) [#12474](https://github.com/cosmos/cosmos-sdk/pull/12474) Remove condition in GetTxsEvent that disallowed multiple equal signs, which would break event queries with base64 strings (i.e. query by signature). +* [#12448](https://github.com/cosmos/cosmos-sdk/pull/12448) Start telemetry independently from the API server. ## [v0.46.0-rc1](https://github.com/cosmos/cosmos-sdk/releases/tag/v0.46.0-rc1) - 2022-05-23 diff --git a/server/api/server.go b/server/api/server.go index c052c03f52ca..2abd0130ce05 100644 --- a/server/api/server.go +++ b/server/api/server.go @@ -90,16 +90,6 @@ func New(clientCtx client.Context, logger log.Logger) *Server { // non-blocking, so an external signal handler must be used. func (s *Server) Start(cfg config.Config) error { s.mtx.Lock() - if cfg.Telemetry.Enabled { - m, err := telemetry.New(cfg.Telemetry) - if err != nil { - s.mtx.Unlock() - return err - } - - s.metrics = m - s.registerMetrics() - } tmCfg := tmrpcserver.DefaultConfig() tmCfg.MaxOpenConnections = int(cfg.API.MaxOpenConnections) @@ -114,18 +104,17 @@ func (s *Server) Start(cfg config.Config) error { } s.registerGRPCGatewayRoutes() - s.listener = listener var h http.Handler = s.Router + s.mtx.Unlock() + if cfg.API.EnableUnsafeCORS { allowAllCORS := handlers.CORS(handlers.AllowedHeaders([]string{"Content-Type"})) - s.mtx.Unlock() return tmrpcserver.Serve(s.listener, allowAllCORS(h), s.logger, tmCfg) } s.logger.Info("starting API server...") - s.mtx.Unlock() return tmrpcserver.Serve(s.listener, s.Router, s.logger, tmCfg) } @@ -140,6 +129,13 @@ func (s *Server) registerGRPCGatewayRoutes() { s.Router.PathPrefix("/").Handler(s.GRPCGatewayRouter) } +func (s *Server) SetTelemetry(m *telemetry.Metrics) { + s.mtx.Lock() + s.metrics = m + s.registerMetrics() + s.mtx.Unlock() +} + func (s *Server) registerMetrics() { metricsHandler := func(w http.ResponseWriter, r *http.Request) { format := strings.TrimSpace(r.FormValue("format")) diff --git a/server/start.go b/server/start.go index 9c76dbdffa06..d745ddc44a11 100644 --- a/server/start.go +++ b/server/start.go @@ -27,11 +27,13 @@ import ( "github.com/cosmos/cosmos-sdk/codec" pruningtypes "github.com/cosmos/cosmos-sdk/pruning/types" "github.com/cosmos/cosmos-sdk/server/api" + "github.com/cosmos/cosmos-sdk/server/config" serverconfig "github.com/cosmos/cosmos-sdk/server/config" servergrpc "github.com/cosmos/cosmos-sdk/server/grpc" "github.com/cosmos/cosmos-sdk/server/rosetta" crgserver "github.com/cosmos/cosmos-sdk/server/rosetta/lib/server" "github.com/cosmos/cosmos-sdk/server/types" + "github.com/cosmos/cosmos-sdk/telemetry" sdktypes "github.com/cosmos/cosmos-sdk/types" ) @@ -207,6 +209,10 @@ func startStandAlone(ctx *Context, appCreator types.AppCreator) error { } app := appCreator(ctx.Logger, db, traceWriter, ctx.Viper) + _, err = startTelemetry(serverconfig.GetConfig(ctx.Viper)) + if err != nil { + return err + } svr, err := server.NewServer(addr, transport, app) if err != nil { @@ -318,6 +324,11 @@ func startInProcess(ctx *Context, clientCtx client.Context, appCreator types.App app.RegisterTendermintService(clientCtx) } + metrics, err := startTelemetry(config) + if err != nil { + return err + } + var apiSrv *api.Server if config.API.Enable { genDoc, err := tmtypes.GenesisDocFromFile(cfg.GenesisFile()) @@ -365,6 +376,9 @@ func startInProcess(ctx *Context, clientCtx client.Context, appCreator types.App apiSrv = api.New(clientCtx, ctx.Logger.With("module", "api-server")) app.RegisterAPIRoutes(apiSrv, config.API) + if config.Telemetry.Enabled { + apiSrv.SetTelemetry(metrics) + } errCh := make(chan error) go func() { @@ -487,3 +501,10 @@ func startInProcess(ctx *Context, clientCtx client.Context, appCreator types.App // wait for signal capture and gracefully return return WaitForQuitSignals() } + +func startTelemetry(cfg config.Config) (*telemetry.Metrics, error) { + if !cfg.Telemetry.Enabled { + return nil, nil + } + return telemetry.New(cfg.Telemetry) +} From a96f8e281c9f6687cdb740135e878568b2ea0515 Mon Sep 17 00:00:00 2001 From: Matt Kocubinski Date: Thu, 7 Jul 2022 14:38:45 -0500 Subject: [PATCH 06/37] chore: update rosetta data (#12485) --- contrib/rosetta/rosetta-ci/data.tar.gz | Bin 45317 -> 43673 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/contrib/rosetta/rosetta-ci/data.tar.gz b/contrib/rosetta/rosetta-ci/data.tar.gz index 6e09fd05186cc948b2f5d68f7bfd0a14e309c7e8..fb05ed31c08174c7b8dff30b281b7872232ebdf9 100644 GIT binary patch literal 43673 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 T_n-UE=YReWf;lG>0QLd^t7GmS literal 45317 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[Mu$ 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%0AQn=C(Pb zrYv}P>phPQ^V~4)Y4Nqn%TJsz^uE)c9)8nJ*YqLd?QFnUg>F1R!C`Y1xxe=8T__ri zf6oAS`pO$$UGYHKw%gwxbHO|B25!2dYEZSK=&iFKI_JvmD{V*j%OP<4cF^4@v9qqc zv(uK1x$6ppaX^NCzFzjzDI2ZkP1#ew++^X>ly4Oto@Vr?3^Hsn6_|oB> zmXCNOml8rx!AAs-EP_8qj7u&Hy)xTi9GIc6g)jWO+iiWKpO)8O?74cHbo~1tUh!GS zYg&4qKWpndL!&X%0NR(HMu>fN!kHbucFyaB;yD>QdH6fe*Ik?|rKb$dv!0N)|NS3* zZ>c`-I4P%-IHb#U*Pq+UD4wwsAsa=6Y{MA-efK2EGi@%6$965LI_b)6w>C5ZSfALIB4|;?!8Wx-}@=?-5ZiXIi zeYC+{k-vNHzwf_a=q#Q0;k9pWymQ+-GXe{qxa;E^Cmem5rUyMbd#++E^(7p!_=+1evww=c<=@oV2fJ9a%(Gi9)=+W^m| zHSrpvPqfKtLbk;uWFx}OTUX8-PBvOKhCO5qm3=WAs&^du(l=ubM!Oo$5P*Z#sq;b$ zu5W$n@am(Jt_zP@a^vGoKMacx{#VEOKYqHd)cixEc&;wA6?*Gnw&Fo`o6+{p0XkF@+&8QIEJhOLMS2I1PR$j z^m6F7aU%@I0yQE%6+~2uU>1z_6c3nxp~2`@1F`}jUU@n%w0GQ;HFq}kEB|T4_}0Vv zGTtQQg}+v(S_; zhoVCEu{~N>=XE+Ab7Kus!TbhaQA0AnzGz-B>F_l<6W)S?f`~8abeRplL9_j2Ef=Ag;XZ&G7rNypokU`=*|@@twVnP2~+wJbK)>i=Qqr&jz#((?x5f>4Y`|TYH#I zLbpB7{&c1I&0QDY`iR3k>60m+ewDYS*Y<%`iJhipOP@UQt$TYfS$Mg@SkwlF+wQ;X zgt0keh4p)zBZphp4-L=gfAR^-yI!)X=ZQ!5uk7={EW(xP`lansLV`gH>jVCPruqWu_2y{M&+Tq_{&Uj^+!8kNC)T+Yds_ip{;tNlGVceS4 z!;kr5+k(cyb<%0RKvT(y?>u_@1TrfOs*r71LN*i)W2ST=lpB^AoiRt>ar&_0Px`dn zymjHd{dzvX->rSZ4dG?p8FTHEu~&nV?!gWzNAc+2K57F8OIr)LJbWnJFK>yOH< zxTCu7hI2x*?8itqUHC``7)M#a0(%x8nlpYfI>E8Pu}^8c#gq1 zJTp##2|JAUul;+jrzzGN58XY@JYf6hi-eQTKK-rId25E|G><1*E~TN6ZT5w1<8#>O zJXmHhj>wG7vd;a-<@|Gl>$lCL`k#LFlMip7>A$L~<*1p79-j?<_k2gcUWE8vI?y`| zWy1G=@tB{d8U7D>R~}DQ_w~;)+_*AbMJSGo427snDT!1v%a9=%t~q3uA#+N|d<~JI z9)wgHlvId9q$iOyk|!w|kPz>=*U)|5oM*q!`}zI%^XIkicYW8|Ywfk}-skKEt7F5) zDTP>zYo9gB*)o0NI}0v7c+XF>q&5C}MiQT5K4#F1Q?{m9>1dDV7K5T;50h&m1Z!Y} zdku+l5CzXx+6Sz^5g!O^CarX1iSuk!dE6eydLl0%-3Xo4zk?$nH4zYDa!$@cLkQl9 z%__ZI<9vjz(=OgMLZ2rgi5(*XWRx{D?;Xg7rN{%+VQZn5KkNg@4^Ol zfn7$bdv9`t1}mEQSm4idGB+PG-qqigmU7gu&_O_754GbjU<9Nf0wVgNgx3dUv>Tg| z$c2im+55Iy%Wmd<%3M>pYJ`8QUqf{7n`}3k?<1|UE_!He{IVeeas&jV;TN-}zT*(Q z2b)pV)Q(-HLVCgHPkxeeUS%y5mH2U@Akl5SAuLy!dE~T;4vu3nJ`hl7BOv_(OASm7 zAXp2V&vEjl(66Ir!ajJm*}@=xA#=lXk{XS##CBW0CG#+OORq$ofr)Ouh2o-h)v2l$W{B}KIFt*iQs~sD!a@U8KkLg~=rteMDW;KYC_Acvg5ntK_y>%G!x=lV92FXgI0e6R2epO8MQ{rX$C+($YTE+We>%;jflMY?FVY-grU zG$HC@qXv0(dDLYtZ>#QER{w{Z-?htUqF2UO;w2slw}wgVP5n5R5Gm*Pi*YFv{W2cS z5PI04{C2AQhwGS=v{$lAZi?Fe<7u6{MsYy$M1M)o(1|P7KlY+ln*&8aS|K2Uok>VG zT7u|fv!PS`Q{83jd(x99X&#S*|JoC*N!(Dj=Iz;`j?K6zbED9fSE~H zVT29)Dm1Xd`_-P1Rq~A&4!yk6*=5jGvzcM@>G61;i@u}IuXIqN3$O@CF9bx=40*R7 zO(grU`K)Of92Xn=>X;?Lz>M6AizG0*p6PQrw9I5J=M6qJyQH~9vQTm_I_&q)2F>WA zWQ+}b%=bH?o{#LGtem;}O#Z+QM*EbXDRG(h9E~L{x7eyK&n-&xkMk`qAnlJvXHP(| z2{vw)c&fSZ@u{oYWKP`b)hs7jXO9%zQ(2wv+a_k#*C~>yiyCkd7Xhhl1cH9q0G^`IYsA(FB-5^NZKF8HN(ao zS!d8zv?c1+m`%~>iK5k3Lyp_uWri6|G$xXM=v-1cVOTTGx7~R=bG;waufb+NrNIL{X)2LXELdYDO(3cwL zxEQO{7rpU9MUmE(gEli0Y+v1q^QL46J#}Up`gGC7WYK^KX#Nq9e)Tdx&Y%^C1va6A zvJBbu9Tti7JdJdB30h@J={UDZmAer(!@Z;1XCz(qaLZ|80s)0I0#Y!x{M%79Yg%G6 zx}u-eALpPud2yO@2SPKVs3#$Kr1r>Qm(}PjV?N0 zR@h`dU-&T8(@4KgZeNN6J{6z&xH!zMIaMllShb+r>1sZQE?(qUxq*O+B?P3KaD|b% z1_U3VCA5;3(64O(5VI#k$(5oIY)uPA-BMVnXK9Yw=$5fXcth|(+OgElSn5k&?x%CF z*FGoiMZsPnd5QM>&jRM>TC1o3tz{2F{vVv2MEVMJFoEtm=KW-i9I> zw!kw|cY+Co-#gav5teu#ob$Ina*~AKd&_NjofA$UINLlJ2En!%1Rn&u=0!?gRDG*A zpw=8(8*qw{WRul6VW@Q$=ipi<5WEX@RTxG<7DPabTD!(8sX?$EEe*mVjbB~?;*%;G zC$|fN?P+o3C^)pg7G>Nws@YFk*Cjha8TV%OMtoT~qVp~_*ho3dxZG3^XS$$+qs};F zA*%k~3W7-hw31@ho~pJBRZMqw(_IsiwED2K(82wNL-FqG-0IpFp0ux~<H{$;~zK zd)>}xf#v{^5hv?9lWKKaFwG$Ds$bv5$l#MlxcrK{+o};}e8|HRzxjy(DTaW!D$AbQ zX9>ZM06GH(gD)9%l;Ea5wW5d^@%LLg%&LQV`W}4=2z~HanJtE&vfsJ%Q66+C**GN; z&29h@4Hv@&#~Z`1%|076PJbll_4vE+vWOfZ4( z_v;lF{(@!;uUvv)X8XIat}SC(cQSCC4yLtD(BDd(pB)i8!r&agx? zGscV|Am>9sRtbA)EaU*et^kgCW(7hLb^Jg4D?{ak6abIC1eKaiJ6I4iItg4%9XDqG;dwNQCtf!wQEZo+dXlOsY#*YSg~pNa+fs zZtO2D0s+|o0r3~`R@{Vg^Z;;7?YzS*Z)QyYz0c#0qfxzJ8E)@0enE@OVYj1P$q#!O zEE#ZEwnjisfq)F4-=XAm7J@wi90NOXrSI79eBCFY6O)-)tbhEI;%ArIaV|59kvwAy zvow1g8_4+(P>>-YL-d=34(@^A!?axae&hNpAA(4)UHezVehBuW#iLe$^FON4RM;QA zC2kxpWvX;X_0D-83QC8ykO_%el2C zirI>|rmPkC83A>7`CAN=(Z|K%wf@lzo{}6140t-(4J(veD@-y-L=%>gwibrzY>EoecrS3q zhq=H{^w(1$Hoc-8#iu+>dWllYxo7ok^U6zgHBFgCGrx>K? zDzCP@W;JekU%`^d^;(qN6d`(ON$$1lK8B7!@DXgunfS-iIhQE!9<7u8zt>~o@V|ZQ^8XdeeE$%6__$`PL^?PKTkGO9!=!a= z8x$400(G~9@WAieB9<>-zgPc2Rj=1Avs0sw87R-J=*u=U;G5|1bWALSW%HL_u7Zhw z3r9&h0wjm@RW|G(Pp@8)H8pxa)1z8MtU|5dK08IbC@qse!0@`UGH}EW#C&A5rvIaI zxC1%Q=CLF-Mr(W!L^@m+iC$v7$OW|Ni`w8;;R0)ZzpxBX!MxXzdDgq z6XV0!eeGLMd4Y^MkcTaBgbQ$l*OFmQ_%C0zWB2WBi-O=_Y_GgA-E_;Hjjuy|?EqJ} zrSH>Q333M<)dpMNj+m&H{uyaOeeg+N76HX90&?&Dc_gNC2oAxfGQ_m)ljvO*@qwuw zi~%pQt?R7G{=%|SmxA_Mn!T4D$~%nKoBw82KtL-T0#aVZaksku%MvA=lO@I|~So zq#e7SGIs7jN5 zHUT=MLmui*=r`>sy&M^da+~FeI~Z5Ypg&ZjFeTh_%e5TgOfC=`h<_KMF8aPAb{qQ@ zBGek>>mMfnD*LuDDuI_O!N}RsgyiMy5UB3q?Xy#Zy1XzFH!E!*jxp_N%7Wl%Od+P; zV%ou_JU_mSCVWzxy>orpEL&>*w{JDc8rwCmiY9ehqhX6J1OZwBq{LByT_H9Q9D_+P z$wk3jyUx(Jk8604AXuj^?e6+VZcz{UlsD_-PKYyME#=|)-w7Hm+d&0`FGUJy(0N-TYhhLpKYHDak3v9dAyy@oZF#ZP={+dBD#YwebH2 zMnGC4Ai8^M%e!(Q_&6r5o;vTC9~_sRd0&uDDLlMT>Gw=*N7QJvSiR}ScGLIP+o_M^ z|ASo-kmn#E#lIg_4Ks(}6POhBhu&yM47>TK5jGGGe);zNTQ*_6+)Eh&4~9pEwoa$^ z2`+{h#d1eT6n^?7FG@cu26Wbm`7ToT(HM@y6foZFyEFXq0qK4{c2#=&pgi9WJNyUs zr>*x_4Z9g7NY_$gn1}j6^g{a^lDqwUgF^;N8-%k=T0ha+{UoM@*QY1^@>;g&uX}u~ zKmhkid>VF4i1D9EkeR4>(~1)tvO*^xO9BGY9|7?<)xP~{9|Xr^(tEc?&N=9?)A|^H z8}7OjVYO^k+DUKyMp-+FR(Cq8@{jSN2H>F5qt%>pv!<4Qzw{9ZPQZjlnuX-zul@x^ z?Rh-YTrTPSKChX(1tsZw5Fq_pj!T-HSGI;&6prdSa5I$LU25z1ws zavRW!MM-}CmRm;~%7;?2#1I`@2ftJZPQ)Z|iFeJ}#D?T%*RO}PqPN~+WVzw8rtIy; z^g_!C+uGRf5$bD>OAtUnMnOQTt+QEmIthYLVN!E9576sk(7G?Pux*!#`w2*{TZkj7FHe{y9&a1tgjHvK{-!EZTXY&@(Y4_Q-;iQRGB zG9?{&Z}as9VY$_YmN*WqfI~p*2?A1DWS7siN(fHIWLK3#%y12;ziQm5JT75hPIr7us-7-Gg1XOAt z<(=c?s`X}AHK{bW$js4Ryn=d;_ZsT;y_6d&t*K3LDOcFe|9l`?g`A$5B%`ZODyHbd z!UB`$7x~ZK>FcAnca&=V;1U-9bS(FpU`Y6iQBj?q`PFAh(Fn-g2uQIvmE8xtAvg__ zp3Q_>Ku22BD0^7-yYz@-hWHN6zK8=WEKkK<*>XeUSfnCq8N%GdcQWc8)CLkhnk14C z;Id|7$b;IuYkeU&9XltVdH?2_nXZTK$tztEO)^OnpEbwr>$EZ4tK&U^*` zw&_Z-lBbu4r-wJm%Zuc1<7Lmi^d;Mu&b*jGOZ^N?*`IQbYOJdGLoBe|?0rs|pcwz_ z1KmeNM6!m428!r^l1`#HrIxe0-M#er#Xy0N z335g;P!0@Qb1;bidnxfc2QW}HDrL+s#flzAAK$t(qHExQnCL*z3tX}DTJvG~ zmmkz#hbRx8ErdRl!X z4a$^qc$P;?TG^8*M)@@4lv3|rE_*$FJ*|DHSZBS!1^zJjB7s=xv8Y%-y;fJ^{go&! z$9-enwu|en4jfPJFx*yBUhJCFzn=4@FV#v%#R`KY27|adaXw0ljDg}%33Oa)IbN?> z;WUw8SGco2XHZPEliMM_W$`my9moFX>=#zg(g~%35ZT?@n_4NJ&ZIJ5&CQXGf#Ok7 z@h>x3ma$E#C(r5Qc$GlZL%-T==c0at&?_hNYBkpMF7ZTAaZnzHWIJkWW7<56L)6;$ zlfO|5qtBz_yE*O9pPXg6A2EYn$qep>BbIgtcZFl1%cxX`<=}J^D&n7tA0=R`bi^K* z8@1;KNn9owzrC$nvF=6UPDF#VsfIyvg+bEj^}FeJ6$2%p62?~jb@z?xX36V0(DDm^ z85LdFp||LzR`3EVqbEb+s%nFKkbMr+91L2ZFo^%^Q3*MO&MWA<{<2?Ul+wxUgt*N2 zceJlCM`))d)n6C+bT+u_+50;~+G`Jm zRu1w({+XltqnKm_;vA}3n3JkKpV2}`!mng{=VxViN)K%^3ShFE4 z&_vltp^yBVds9c;r)$rp9;xJIrL7)}be*I}&Z0(;)#jFIRUjXKG^! z8JU^KCZ(r=gS(xFgR2vnIz)EXH%3bFY&%a^%jx47fI8xt+S86$4T-2MJbqWx(5Vrv zOm0+DXj8S>%NLSmxYAx)awt8L!;hr{OR*Z*DI6SdrF`?IO%psMK>P0;dzjh(TPR|- zC!u0aTEEn1W3W?K-s|)FcT*h2zmmB{Lz3F@{zeIdw+}_P7$bXl7G@YEau~#ragYVC zBL+%FrAyakpCx}}nL*0aF4=c%qu(OfaK*CP(qmR<-|VqIS>GawNQC!$uAPRfw+p2O z#TM(mP8yTu?jiv>dQosc&(L+lK-W<*LJ{rCmR)ZMW)B0}Ec{yR@J-x}mtwn$GDJ+> zUO9H(m!o`?`HoR{uZtn2D+L*OE9~6sLU#3D!g!G^?vSdB!$3Ds@vaS%bx^4o$*GFl z^U{Oe_-gdZW|PjpUimpVI({4}jWMDYIhX@43=$O#;%s}aG5InENOvO7n8x4w}ornUtI+^$N8AE z4NAwPDepr*G&*Uk2jwYZ^l9v*2?okUMU8(l(i9)9O}rOr{^gjB^~x_#Y<|6zT5iiR zNPeW;u_}iW{lPKy?O)B+g-mT*ykOE|iuci3jMzL`sNgrhI@%FtX|q%I_twmcBazSQ z>u>ZeuJ5-F{pFY3aNb3ys5Z|m@GwXqFo^81QNINV7$_T+u!+s`3TbvX*5!5E74yYt z1en@hVBK=jUF(-edRF0YI26gq9tDUT1}!fb$i3EpEOOZ8pi;R%&3Hu=$AaBPD;s#- zV#UsR2Ktg)aj}W%%m>|s>sppuBNoqGn-m5eMKDMXW~*NJT411DR1yaSPTnsXQ`{fY zEu!*L{dD9+vRy#Em*wslo}9|H7tSB1x+tbJto^+~=q49x%W`Jwk{$lDew85xx`~P; zRVAS<8dtR_SUmDn z7Aj<&gK;(NT-#oqXjvWE_BLY6$>FRN4Xx3meLfdlu9%;~n;;960c04&HVh(p^j&-o zvNLa^QdS+~S_*UZzmM3dL8wfvY%-B|z!tT!^WHz45hHy_kDIbHIq4|-{_)0x2@$Hd zYG5AnioJslevJ9NZ?H)KsUiC%BWHLCu-U73Nk zC+)bIeS4RMaD~`opgdHpBugEuh`NG81Fth_&l^8_ULSoz;?>#TY`vr2zTM(zyf{5m zJ6tHm!;!y?kljWUkW!E$(Hn~b4vP+1UBp0lQLzmzZd~%{EZ3LATTf^_fHz2Akg0ec zYFi#U%xvi4DMGqTt)|Ej8w?T;4B|v=_-ZBcpudMooLNk#Me8mlw`6e}ereuX!E0af zJz>jJZz?whUQhHa_`?#1pF;sKXnDXO=1tdaibtgPJ1T)KIrmkcIC7;(VFI_6J+93w z+ovWkxbYz|gP7-7-69!=feKIw6qtw+r0&KDe4%gke;l?bY%VTl!NFy z^X9j)g-p=>$qAIs0}zwPTB$x}7KkWDV6wKgC9XvN1Qz!rt|2f}>sQc*gMx2};shMU z??D?4sy#%MCJ=s9cc9Gy778R0rqvCn%>o6|5+w;NQ$Ygr9m5Vgb8HikwB|#eu z3T2?km70`0sRlr49U>=zgVtr4uKFPnLlHM6#fAn1lwCt1&}Gkjxsf2?Y0Hi_9<<^p z@|v<`Xfr^SV2Eo8Q#~YT6F?y;lnIlWX0!>QBr}M`W37`lC3X(W0wsp;9M`}=#q^tt zVe%Rl2)C{Epsx@HDxn9(IC%|=8CQ;VY=WTD$sZ_98R#>#h}YzB=_h{aCLJ{TJ5bls z?8S(b;91t|iIrt(75p2uiAoqOjy`#fBqgONqoAlLBSre2yhf5yke8B`l9ZB@Cdo_6 zlSoqXk|bFLdNc+jTJHST<)1xwofxLb5ZE%Ru)@*gEySR4+5U=TIH zL@-F{J5Ktf0_wk@x6W@ontqDamgvc=RgFed^@RvL|QJa+>#f+?A ztiE(8GvO@L^k`+Q04vKdH4L@kZlk@ZHUSQL_{V5bGUqen6-7%r*EYRiPS1#coXcN) z-y}+rxL$Y#?OgXyICuCKc5%@=4=C@hRj_I5&AxXvw&FHlwf4S}|JZj*8fJ5<+c3N` z;6mM|I`fLgwmP|vjP)TQe-7R$ZOP;E#OMA033-mtt1IRB-CeRg^sx1Z8$B)Ab&UlQ z4-RY=71(Mj*x{S|zmVtutB~gz>zMn@2ao8t!G#|NgdE=18SZmdmUY?eSTOv};o=G3 z+v1Me$VNk!F)(}?25pELc+-w;3wj_LCX{cY*=Z2%!`AOCYW}+EMcP%J++KYC_z7(s z3yu<34LS&55Cb#tW(kE4re!o5bL^}WGZT?)WZT(xwRrrKtZ==tV1`hMHyO{4`?mv< zLCirL=xLgDFoP^Uph*aT4~mxt22=y!gTlsvapjDov#~Hpc}k>>DjWo;VR8bcw*sT2 z$WvG9V+D8lzjrOjmvUgQ{^Y{NuYX2k=mLO_eC%RFIZYP?)*3 z7=d08+v@u8#A-N1WZ>M0TlVtg1LqZAd@O!x(evq0#PY#X9tvo*ta(NNAKvldaJ2I{ z47I8yca^kWP`0q*Q;k%NXU}gue3nUEaneKuu>^w%V}x7On7e-@-f5SfZfsdrOxkVT z=={LaqkBc9H{FYaEe!29P>eLj+11EVI3>KLBuN>0NvT<<6(fvK_i2gV*p@%~jn1z;jNBP#iLn%CTbqidr(kLt(wnswzf}A=tWe9vpI8aV>V72S+J}XQziRLMP zGvp=F%+x4 ze;(TrM0g?T9u@t2L=@FnM@b0>2?z#p!-$|gR$Td3T>jSYb-KEpuRN?0u3+Pgd3&`c zpvBhZ!&uxmGaMdG>frou5Vwp766O^T6bQSfJ>EY&K4cUoiRp7M)j!An#9LH7j!plU zZZdum4wUQ-TH7#)Ye;PtVY4m>P`wUdL67+$0hMn6)_0f>5@4YV(17_M0Twg>4VVuS z(6>V1$He&{0hST~4VVuSV7VC3fcYQ+)sO%dnV1g}V2KjYfcYQ+Rc`>6cbE?nP&o@= zy^A>tMqpvk!B;9}-6VwAy>wKeWXNGLxw3Iv)iF>X{a8lc1}yN~?`X`)!zvi)13jc! z>3vw>H*sgu=^g&O43G|wsTLQL?=d}tyCzNw zmCK&1FRSD|qH`sBP36j0m$R#{y0~`<)zy>(<)a>f78t3nqxXUVX=X&tx0|nXLuH2h_1OrV* zr9FL43)u)EEO9e#6G-boGmAfG5ssS!SM=Z5^p|=L_MQ6FwcnE~GNw4N)&slt&=D28 zN&ZkFg4@l2Xr`y8ag4L@VRHUZ-bh~jx^A0yo1ew*NYH2ABvyEmbzSB?N-`U6&fYR0 zb-^Hh>8T-Ee^v9YSoH0|?nCR;Ya%zKV+YNLm7{f6tcWgqZNF2)29eFb*?8s@wl!C{KHHfXEo6gOb8~`&LGpn?6w{MqYglW~>$V^J#mp~P zZ%NNBo24QrHog-cy0Jum|NBQ>>NbciH+L@;(BgqX9Mc>NRB~pW=b%0;z(y@|0SC3A z0rshx3pl6?53o(oT)=_-Yd`}S0q=d9XEOMsUpug06llO)3;_F+fdb4HoDp@2fOCf>p?6qWZ`YhoiP{#G0!53zV#p$Q>Ga7Z6Oncho*j@#cW9T zF|%NQ#B5-HE@lJ!Q!yLJXppLA#cW{zQOpK13uMdAh}oDAC(~m#<}>4a%m()7Vm7e< ziI@!p2*|_yBW7bh+|b8tV1GJh1DOHxXHJjVKqi1bR8NoD!2Vp!2DZ^^%tZtbu}p3W z2JX}Ae6P$dKh<13u3S?RU7pb<6LD=t;XPZPIKMy53%^{Bp?D|pSbZ4=-bp3_R+g_+ zk5NhJU1y4Sa!s458a}|@u=d<<@PI7DY;Hibu+u!!jK5@>cOWw&%=STi-@6kCK4}A^Vw^FnA z+=}!)%TMW`!&Cn~#1cQ{9)M0*}NPsvduM0G< zDDN6!!9aa2#|1}Csxd*$n$;=CH9eJTQtvs2crN5wbx|0(G9V1S??y^mMpj{7em$Fg z0e&4iw>k2SMLaSp1r>`|2{omibZ!{QD0Qx?6m#XF!2TJxXvRoF%1E1J(Z6WB@<1rp z??0~@j4djPLNA46A7cxl6sd$%wrDI-*|#DW5h^50$x^a>iK5jKiAahHZM0ERAqi0` z={LINP8shR-TUhg{d4AQ&oj^V`J6LJnogUt#V@cX?YTT;PIz^s{6g$){@8RyJ?g@M zASe_Q3OPp4_NTB4*~&Ys`YWfqgw{5uryg6sTF~fAl#Po{JhMxGw6G>M7zSWbWqBp) z^2`vbd|jh?*nJsqVbO)-oN?zrwHyz-SmYR>YLRi?IO=ShtB40R+9|=JPzZknizbzw zZ{?SbCC{0e3NGzNQrrQ30Xm(!Em~s(1;e6BWU`u?vhwc}ojxpjM3?`nv2x_B zuB+X4H%K2$SW51mCNJ%Hb>vF?^L1H?ZW?1YVOW&@??wx-Oi$c-Tb4bcyDKRaxbkS1Y9bsr~(P7Csofo^ZcWPVQ3cl(8 zDwNrtWf}_vi$Zf7g`&m)Nyc{w=;{aF4H+>45)dE(MvQ=T6i9#(BM?&prcy9q1SF6^ z0*n}ezXycGY6W;x3VNpEz>~u+B zX|^a1k(%&0`YSAo#|6sqJvz&ZNdFN09Tr`6yEjLd5F3-Bw4bxo{g6V$@KDf!*z;XA zec4D+^3`g7>W2M0EUK)aqNYHrDpwxD;4?LSGcfZN2cK$J^z50hFZlg z&idD+|IYQKpeUyr^`Gk4AGKeT{#hoCr{b^nc>6t_Tt$!0=ohc#H4`+F2^+DzeRul( zVqvkr6;F;PPnZ_!m8DDSnAuuy21Vb>I#Dk_54G21O`W^#1m3)n$AI5ol&WzY#G^Nu zze1D(DyzwA4{Nikgl|}L%j%1~;E#PkpZs8S@8*2|uN{6`K31WGBu@GTV2pTM_2_Zy~XPa-*)% zd1u1&2S ziPxw*Z7jBo{g5Sfz2`&dt{zZSsPcv&&SA3+zJ!)A)GA*gt=bQU4HXf#VZ-t@N8Z1tykFPY`)x_2G>;{9o##W$rM{pdO&6B8qH&|U zA!&h39dW_oxPxe5a02VPO(ChRQT+*S_0c2|Mc3LAZg`F|(FA$= z)9aezyL^`B{mHdL#{2HFUiG>6vMhHb3%*Nu zrlmQ6Lis^;YI(at@5KrQ4|%5OesT0$6DeAf<7QxIxNc#dW1WZ$jT^4R>+yMJIIh@b z%lxa4?+%n397x)IwfWjikBcWz5z=u>7WPR}jY6{pg+iopBh-ukJ>QNuI>fD!Y(o;A zi^)F1%g#t!=5npIhz_yqE07%+o|?pwB;}(OmMs3hfcfY|raynT2cb zX*&jT1a1zM2oSd{e$uon<%9C~Jk!;T?ui@V3vKEamKN-bF-~`0eBfzrzRX>u6f1oRgxkXH+9)aB$hn#5?{2uPCx&#oin?mLDKE^1Kl#=mekV2PDiwbC!KYy^w04BX#T8i7rdb% zPvUBr-iH-~W{=Few08^axOPf?!S#{d!j_(MsG4UwI=k6YoONjRGZBfjS_YoCZmL!i z%&*_w`6kzxXJ%P$?o&>=gW|%MQa@kvTVPI26Fn^`6c`HmN8`jh&YBkrb#_O{jbD^Z z)#Ae!vxSU0eEhOqskpOOu;}&X?=zQfl2B-vQ7AwfH}pIAhm~pTDi*hN^cppDDR}Y7 z@}Sa}W+?1jinDmDRcFb=6OQ>LF-qsk7)rL6;EIo4;aBFW5?MR5WKL#O=dcR4TZOQqkN}46ti-(9rnX$C z^s+PyzuvOCQ&v20%X8Z0X3vgNta+Xtj6wn!x*;kT$o0a|-NJf}BHgTW)JolP@G)z- zE~~={`7O=mm!8-L9&BVO*^5E~7`lyj8GZ;h87O@qwJs+iYEn|3aYp0*jn=}!t-)JI=dKGF3}7m4sT7)aWr% z7aWA`)UWBHkN}2mr&@$1IHrY~nYuWHLMukMEfOB2?g=|dkG-6q9VWz@2tsHtvct!*DdoDo&Sjr)KDab#i z(-sMjLTNi4ZT8n3Cd7$$aDQt^6mi?;nWf=Nn-34w90fSp(~C!6SzI#ZxD{fRel#Um zh;RKEd*Huqi^MdsEt2&bS9k4$t`+v(pOo0*-|KrZaR>^ja3)lel2^ZW`R4YWQZPwd zBq)MEZHqKMc3|HnNB}Ybk$pin@FZ=K@F$g04>J+}57iw%16(p` zsqXkGQQfK1(7W6OsyqIVsP5EHLHOivRCh)q`IYL<$S20B?)a%u-SPhg)t#yYS~dQm zx-$|DE!7=AWvV;%6VM#}mFiCY0K`80mFkY48r2=I|7a_xHV$#a1d9paz z?l96#z#Xj2t6qjfJRqc-0A`o-174r%yeDSa4FUW%ODo8qr5=F17&!nDz^~$JE%QF= z0mvKk07Sqsn`-G(cLpB-UMJuT?w6^~Vnuv^2u{cS3a_`dM=V&q{#BsxQ~~9a<%t8HW?|Vy?d*IryMDs$g`E$uXJHvkyyd zp7ZonJ5jN@l)^+HV#48&7gK`66<)irW?b%CqL8G#(l_Y#9h>^h)+mSlMb;wBEB3BD zvw}ikA!5SeP&iY9!)GR}b!^zIUdNu29-QSDQ&A>iztd>&fxz>Sg?G*(sJIw4!I-G^ zglwO`!!2C3E^^vK`&0S*yH;DMoZ_q8ydlI#EMFsBM`zIuTWYqkVP?puDZ$MB<}wF% zK2uQ_SP&#>UeDepHOok)mv>S9jh?UF!HU5pKhpg#U}h*_T5tFt^d3Z9P8$0Z_DL2u z@nm(Rk$c(Kb_soT*IHg<963s1;Ur?h%+TyXp?GP%F|k+`ZNRS;GO%Em`cPW3iTc~# zICP&(A8CjC@Y0m~EVjfML~NKDisw&YX8h0pA^aW&_%W1&Tn0!0OF4810#8X;%0Xx! z62MXp(ik8CEaf1P2NJ+i4sw`v5OvJDWDD?fSOk2UZ6o*6r7&ZYsO4fE4 zU7_9`_hQ@~{VsfpPUDD=EPRsRYO?#LVgXN%Seu)Y$%RJqv$03eVd~wH_#fXL@e}Wk z?VU~SMqf{~Zan%nqOgytgDhqxhYdTbq7zkf+dtaHZIJjr$iEbhDU(%HXn&e*(&`pI+itQ= z{zB8jF6V2fYgRt%=!;A`;IQh-Mu)ECRUxSzf@8X;QaC1N>)x00PObFZw2F8(`$zA? z9q**pACHdiEnDU^vtID+kEsI1ghGzdvrQ_=)z?15ej!6+|L6&W{> z(%t!&X_jk_tGbY#bNu2nJmznD`&HAiJ{Zl0m(?Y{nECYw+9+>XmnPd2(8{rdTG^V;t_^(2L3P=Zh>8hQ>z zW>8xEoULAR)D}Fc&1u@QrIB0NOl+`gcD{FnNM4qr74@R`$Ax21wDcTWd(O4shCttl zsg+~0cgKNu11Ixt7zB1Px1DNR{qX4e4fZV4h*04eG`CSGYK$_H@$CUBKKnP-Y2!wq z*IMv7mk}dSJuY0Z%YYHEDi{)A#0XTd3Rko;U<9n=g#;Ke0@Yl?MVX9DVW<=p5@5s# zRL%<5yE0$|EER9YOG5$}g<}L1TKJx66b|56k&{1GIS$-}1~i3@2D&<`95eLu zu89O#ISF1m)YC^ib55=%cZXj32=85e>gMwQ@v{O3-051p4ZccSF64KxzPKG;urqkR zrfK#~O1E4O(%#cJ*7$~Mm`tbf4MCKHIQqRAN&cSao@0$~QgxZ+`8}#+Uk$U&b~;p$ zY1kjFw3D--)uZ~9sRm!&o*zHA6jY|do~0vwvhpAcuWOF~^{#DBlI6#_Hi_tmUG-Gv zBcX-Wjg3d$Yv$%z7tTCmI-B1f1C3MAuxB& z%$#%P%sg|>-1NbCl=Xe;PL14aLml%A3&+IA1{r=iujR-cVtJ@4auDNH7Jp5BWl$VV zv^Gv~4+&0i3+^rfg1bYIAi>>Xu>^N_S=`;--QC^YZFfK3d+(30YO1?>=G63=n$zdB zKF^lP?ReuQiO`zepzzG?y?(CXKRl4C@r@Dtv=&nMi9%me^uND=c>zt=m zGL}G#Zp|g@wa{KtY8T=+v!A^+77ww1%O>8Qg~Nmz*QxiWFDFu`th-h8e0R{tJF&D7 z39j|=aJU@Bf4CfNptKp){}|Nnw8KBxWNW=`F13_e;5nSdB`i$(r-HxL%{T3L)dZhb zg!t?8Dr=kqQ&@YR#~O&3U;Hhqf0n5pRsJNsaIYd4ICB_oXP9aAx|`D4LgE^X`5s3; z@X)7VpDWcK^J?@2uD>@%R0W;ox6}Ku$Jq_bQcy`+C2FVLjv%PVZQh9ugoM_CbWMy6yJqhMFyWhbQ~H!!GGIt` z{9y;-fcn9T_E3`PgqE8{RM?tkrIk#c+@2d&`dW zO}M{}&0(JqF_A3aB$ZSoEf)^r=~1_QkIMK&x*g;EF2=)T?r=Is%-3OxiX<( zn`!q<$g&g^aM}2YJ?J4*3w-q>a$Q%1*tT4q~U1PGscwg-<@s)D8u1Mp;=tCxOZ3S$oI|kC#3!K^f+A zn43j@j_j*5xI^jyJlhlO&4v13?{#ycN7L|kI8&jt>7cd~G*qs-uw|~SSNDmEYuTk+ zDy`HVoCN&28Nuf+&~RniBmX1FRM6u=6HkMLa%iiqBh;6^5(*ECW;7bv?O6dO_G}-` zLmVd8i%i=GhdkByUxskgHwBeo2-Ejx4Q79l)jxOM{);XWwbC_-hR9dyYFMaeB!6r< zLll+cF!it0(?Ag|Xw#JLD4d<6NEsG?lFc4uS}3%ypR9LH%3YZAi&gK^5z(e7zq5}u z5;T5$Kn#~>#S*_5O3e41ED>n-o%=wS@rj$6w`i`QWQ|%-Rt8OofQHMYO=@%X-q? zsX(HP_#JYT(@ZbMRlVv(|C+obs;|!;h}4j?b8Ev(L4Wm7$BewD8|z4Byl7X(2JTF- zN(r@(opFsF@!+|2N_|~7Is&#jyZP>yg7&@w-=@$^cg9O|I{G}5&)EpuAY;&IAZCbk z$bHh*g-%aH=kZD;U5ZX4@8@TW#jhFf@ahDzyPY-w?npW#4l%gNR1$bDi?@GAjl+}<6V zc6cAyODP(42uF;t8bKAgJjf*ndh0GP@}PjOWVXZS$cu8wfX8WjCxjb!4Y#SuGcVK5 z=SG0AdOj{NvDyRP|3my&(~k0`=C6s@hW^thM8PCU<`%vhvKiK$rhMO{%eahj2CPkj z4J{i4G^0!_0^ARZdOz#CTpp-=-!FwLGShcJ@u2Ny`y5RN5Q{efx*<0b0UKtDV~UV{ zGew?KRo|@a7bTYCwlhSjRFz_G+`~bZ9I}-L8tQ1)@ZVok+)!~Ei~tY*)8!0@wb$~m;vkMKCb(f87-mLglB14h`*4f^eK){h>7yPSNKpp9NpTwF#y}aRm^V+po6`9CisE@_iow5ac+T}m)6pDMoP(mO3DSa zDkk$&!z)qCf~`(5-@q^GGt$>;jIH4;TMF4_N75v~|{ zEKXN3Ld2SmNB)s0ey3&#kE@P8G2)M>q{hp!hN2;&d@$Y5r3L*Xv5zfwyF><=KA1|s zr>+)P4P9O&5YOVQw?{g$+$4sNr%K=PXc8Q0=aHp%X#;C_156aFFWu1<*$tJzw4)y* z!xHASpX~Nb9-a2F6APS98CM`Ghq>=wC)c3bx^iIMz|#|koIv)Iy~Tusihi1CB+mYg z2aKMGw={b<%Xd1sH{m!%$&Qail>ePqBu5wbzP z1%bkralT1%likrvr+qoE(xApyMRo_r5qjel0q1-z#nnS8FPCJg+HYDFQQU!hg>s+M_lSp%Sqm~ zA*R(YH%a=9MH=q!@77LfYrQeGBz$Ma<*@UrR_MZMBQ^mKISnoHF13NgaN>$#MyNR} z+SM=<`&_J;%gv8^Y;scpVm>GnHpU_tWr*L~`ITfNUn@n25pF_qd!E14_E=~SBLIJp z6XtM?$8sRA7}nGOh82K^H6;wPrk#s_{lH@rP{#j1F+njd5vppWW0T>3Y#lEgzXNA> zW6-YQ~ znb;}fys<9Y9FYHli4`C@5S(4V#-VbDgWubM%O+C_*j81F=zoEO7hMAevLGWaV*VrJ zgv~7`I*0tCi!4?gKE8&6BaGOljiP|n%lH8si$JCIg)c!QcvsIPV(176hmCn|LO^yC z3+F+hv2qf%@wgwe5Sej}x zyFLWdkP_qOkpm4q7LNRu)G({;2@oJlh84#`H*Kp*=8@Vy5x;&g@nhm3+u*h;TL}8| zxtK@f+<>Sr+q8fZiB!4h&Ff!#BVygFZL-kz&=gkDZ5}LIQy*J$2C`yMxZYrNle4oe z3PuVD$g?^Pexa1sjL5hK#5*-`3KbhL!1Zytn~-oAtget zzKn`wR`B4`FOZ2`nsf+8P5@2gq=ic)aEWNQLZOnSfW^uu2^Yc#mMnB?1nQBJ!J1`x zRY3__knr=>VOUFu1qEaZUNvA8%V( zz1N2~q`9Z`#HJ`UFJtmL#0Fc8pJaFY(7iFWLRwTRnW4WxWu-AhTM`pgo40yPHIZ zf8U4#*tNjH)!Wx(cGtueFVu-Y#k%orFYtx4$!Zt{`6s9U6Ts3dV3ak z)eSH93kC4I2K=o^4~(>s3n_}YiVnTFnVAzSlv>N3QT7M=z!$sZaLg_wlCts%@T}7_ zj(+C}vN9q)pufSFh^WJQiTKh}Vse1A9;-GPhMNmh?a`+MQz6AOiIZc-Gl~=XNw%{f z_3L0mEhdt*Q=A06A=l0=BO^;je>qF8$S{Qm?IaazhIy1u${tU0H3!X0{;(L-V*jAllLHRyog#kPw@lLH$;|cpp-QnWmUSN$XNDtQc@_(76y)G_BI&X#!K`47>?PD8`k7KB_W#@fuCuS229L_zX>tZ;x`*l?KZGu&g5_ zY6!teJu8e_4akHt)bT7EV(48RsrsMceeZh07UX;AyO`#DGASMyoGdA<3AZTM(*Y6w zEXnX}l0eU^q2u8w0gbiD;Vwo2uGy5sp#O?-j z>TaPWwOCPK6`EMen($B^EWc+^!X7D{A;{4QN|z?DS7~({s-!-c2RDDvubtoBOFrSv z@nk!a&f9Jb#7;uPQyAQ*Hsy8Kb_*WePQctgX6=N37A)s+zO_v2j7WVvusFD7g{Nu2 z2+l1^8pjsibbwe|_8b5Q&A(YAI-GAr*h*c!1sA1MsZCkZ3^+u^W5fPvAeCfC*jbBit)#*Bm0y|Q$&<$>sr{V^$JAaUx-#LuxuH$*gD1E)$TOq+NOJNva zu+=rAnOrKnASv(sesqFBPYjN8{xV+9G83?Zi^y(uu3380(CKG3Z7Wk=eNbhklhr^e z7-N$5WrE~=aUD-_^USyP?qNf`ME^}v4L)3d(e6Bv_{r7ifmHNm(ZO6JEiK~NZe20S z=d@wQZ9eW|sf%a_oiZl}Y@y zHhhg=HfucWmoezpZ>%h;78pbrkk{{Gg3b4f>-)MOc$4e0Y;?Hu@1H$iSB6HXb^DTC z(tG$fi}DVRMQr*rDf+Ub;IZQax1g_5hFRFDU)Wt^UU_~7w68#ylQ%&AZQ7DjBW3Rp zPJos4jw$YuaU~EZuW!)?#6cbH6wU13Vy3aX$0uSn906zif&rgsQ0s--k)+YYl^-P* zwUY44Gy~6W3b3m%Gsr+S82I~yHJ)?GzO?tN)oWCMlf^LnU}A*IbiGr;e2AHr`gEXr z?4QRMw-x6c2Q?r1^i3+OiX{IMo1?d6ME>`ac2=LHiE>g6K7Lb$R;|$HzaPtLgQ0|k z?;27%sdzW9qt`uGDqw?k;Hl;W1p90`G zyewVIX-ZB|uG;HlT%CNXvIU^#s7qGqV0o?UWO)S{oLbG->DWPeA!1%5AT@ZEJbDx< zsd~{Rq5~9&5jvr$b+%F5yYam%*exrVa|r9xu^FsihPWLZ67>4L zv#$0yNlbp^L~UK+o(mR!tc2?f-F-8UpZ-@cT}!m+sTBArAEHZussTq6_R+1Y5fwu@JfOimj&M;xMBS>Pg zUP&P@q)K8T#pB#*QG$f5iqjAdfP8lMvy} z$Pw^LG1UI;3t;|U;%j?NEpdWhQEAb?!P>5J15n*eik0}VZq%gb*CWbQd!^&0XY0gmxfk@$dJ7} zQUlC-d`T%$J!T4c;X4jshx(W}zmA;XJm^Gn@#+#rI|u(r%6?c>wfdulO`VyMW+Sas zPEw{KObPx*&6lsY?bo)cp-7 zxmhdlvvQwMVKCVWC4>MqKAh#azTbSOy6Pm@or{-;irO^lJ2`(6+1K=>VvS)(RkScT zJRx}5nZm+Sj$5@rjqE=W1v@GTJ>P&rTpKYWN*B=FG(41Naq?D!pcUnk`wc^(WGyJ z*!%1P&3~l{KefX$m(Uc{VH@P0!lB**H+m##V;&`+$WpY*e15T!DrO?IbRty(8CCwQz0szeLLJn?MGdM2cYNKv(e7G`aIU>R!VPy256#f&UhH>`D8+O&`kFx4 z-*w~ACy3llNludX>~_1%Y|c7@dzsN0&;9xJl*Y)aa%)sfOe=<~PSWNKcSWBLu{pal z)Hivnt2|~9?5aFVH%e_%Oz2S)r5&_Y*`{o?Ts0Yv%;ho)u>IJ}%8Me8mTZs2s|D>D zxnPIBar*)NprRVk{V9HpuL=fXuB~|z*?K3~1G~Sj4?DL=BD(nC$r3GMTmFeA40na^ z;be;WF2UoQb;+j}w3tI-T*_74sC}>IkVfuc%(heO)W0*URKt}XLXY6UbK}pdS%eoH ze$kuGqef)KaT>o@I~;Z(QH5*seWpZcA1fQjHN}+Vs27dT!N5Y0t`4J`JV@uO(rTU5qsUa4|(+SG2u)LMX;g9 zKAc7ERSJ+K_(_3fYwN=X6-va;$B0H8&n_lpFPDck_BD=0i`D48J9dM*_>JKo>iofO z-{1pj+|BKAGmCcywcHks5Wk?KS{I$sYtVjdV6P+1Q{+U?5TSZ%X-{7*LRUl=HfN{e zZwce6EI9shXv&K4l%YFkx*j%KP-wbL2ZuC18?kSq-e*p9OFx--){mV8NUxP%Sc4>eKnKxWy_=>O1re z*rqawv-QOza{os5X~XComA>A5OY*gb@Jl4 z5AY?1PM`u>B+yu%#Q3@i%Un~?MHY(nz9r|%k7V!>8}2eDLuF{23L5R?ny$SlF}yi< zqdM{BEJr%~#c&amVb;0garQSpLnWiTC(J^NncGUTZ&WUd-c}$o)OzPGKA!j)UoJ@# z*}ik{NXk*gm;SK_%KR%ykZF)1S7qIiY@n-PQZ`J%RxkO@QyC*`%0_iL@r%NtIkqqI z!xZ-&fO4vQ(cO_Dg0_sTdxKwXw+GGYo0VzJE>=B5Y;v*DxrJn!Yf{;}B#le^a{|Gt z4{wNYw$|p+gy#1Dy#qqM9zu^-JkDy%0WXE8;3u3aGwDaDjH_CFfUQ=cL_g0}6kQx$ z==i_&?b}mOo!y?&L}NGCbO_pJ{27d-vfY*>)mdMb8`qi1!CcFe{NDzmy3o{!nz88f zaA<3;SzmP@PirM+_r&O4JC!wlX@8%gDcLaK6cE0OYGGKwIDzLj{Oz^(KN`J@qKIe zdh64J2^$2j(1IkmsNWFJgs~t8r(GTe4iDKRSCS?W>jd9#gg_ANL$(}Z63^R{U z;AZ4!h?l`@sCC36Mkjh0d2lZLAKk3D;wZ?1TrW35c4QtJp1|l&o;kL?QMKH&rT%51cCw|x>)Iw zAvZF6x5CkGCjAh`eZTc*Fpc{EDabmccNf%wy-f|@mI8^zTKhW&anGGO%bt%MqUt`m zAnmg+X;%i>!9bjDwiuYK4PH}o#jHSfbAmsIv%O)&;_~Gcr9`9-90UDBi(k7)Zf-C|ajFq`1tQ%1ckoQ^onRVehPM z%-eMSLS#@+emc*X;=H^5Vvyv_)(Xa~@ArgRy$g+~#^$W1+_%*TQ>d_PKDg(wdQU7Q zW~dR2oeC@t`=N?DFp|3{{#xi@2(k!s2po3kZt)@MS5ip}NLZE|)%ZB*c{B5Z$i>mL z`Fbk7ql`>WZbecsoz*d&x`7gLvkZj7JrP8n&P0ob!8E<4?S^U;KxW`G>I3?PJC%uK>FgMn<~0trIKgMQWY{%`#}xjG&YsY$f8xwM`(BfK&+$yBuIuejJ3>j6lDt z`jMo4u7utY{A&dzYSwJ_9r`EhJgZ(^3Gz?YD5OeWdfcC)Vc3-||MO9c6@A(X^ZScC zj}ij^tmI9JZSUMZEgjqHs!kh`RzfotZxc+IIwK>Oi=q4RK`rUwl6!@~lF7q=h}3)O zyF%#!J0338chGc%I-VLnE9JvizNBxbWwT1fbs%B$aRw2VlfWhS&x z3Si_hAYBoSKyyG(^8Vx-DuVqnE>7s0iG%x(1y1yczK?%MR*o27Km8giO=RTo_ZweW zruFI7SF(&&>Ifn9U50cg)bb;v?`2bga%Ma0(@?$RXI&J=lV~Sq1lU$&M1-oEBphvt z(wOzB7*m1UyqI!taj?s_rvI9V$E}tg?i`f8N1ElUR%f}_EPl7uru=krU1-b z_$}z=8!e_-5cI+rD8LirMi{{8{9I+Cd6mKCzIs1kGNdL60MPKrK*n7Cn?IabVBF76w;qf&*q=|Kr}?iYy0AzW&s#r?zXQ*`E&D zc5d&QdS$-}>PdwI1woHO3Ou=kI--elTS*usN6C^k4_;f_b23EBiQ^$0pUA z4}a`%Uf{I_x6W)qeiy+t|17zG$li~8m1rDp8-sN7(rd zN8nTfjz?DArd0*ekKb&_a_O{%kqA~<2J}(301^nOGV+T1; zfHJQKRD*Fw2LM+bmEgI(jg)I)LaOes7o_D7V8STxM?8XksA83-9xAL=`-n%>@C>3I zbH}8~shfb^Q(;aYr((eFuSWNn$15dBu}Ty@!2+N+k*yM(uDNPQgA$AhsQ;%MQW?i= zP^H^KgT52)Av>e3AA-S$Nje`(>RoGQ#)yqMkNi0_2%5$Up9mjLq-T0odf-c*E{#=F z*ex>JEQu{cKmg3QkMYpn(3gf*<->6Y$p=l0kV&tKOpNlXd9pRKe4+quaZy5YcUVef z>R~Q{ReZKD=vfa7m;8xmtHfWoa%(}%M#As&)_YP6oeY4=)4O3R%Y3OL^uwmF;hG)1 zHVj=h2R~rzO^&Pzlu5n4Pj;8mrkmFS%$6V4Jo`n&h1B>7*qpcen5 zf2W~`O6rzumECLVP~d2})r;jx^o?{0R4SF9`6n@C_#mjuyI2CDcdBe}x7pWCO3FtZ zeez(U)kYywP?xMZ3>NV=6YviV}X>+m&g(QI6#rr>r z$z{6+X6IN~jN`wQV%=)TWaG<9Kff;nA&RkHljFWcdHu`h&y(rGHadi#2Y4{dH% z<`((B$KvBZ>gCk4`-X(;rJ9~;G+&u0hliDkq0L{#`$`5~ z5)gy@35*+e;kR88^9k9nzuaax##3QTaZ)Bmxw6^rDv_A^+zT0l^nQoEZE2TAYJy~r z0ppi@i&(K2ymph3>?{;xn}nP3*?T9V*k)zt!&y}J0n=VXTJ33kO(!_-=<($S#)NCT zzm`uo`QdFzDlSH(S&$sIUjyOy<(7MkV(=G!I%@;n_<1elcj{QNiAj^tsC+Vk;^&5` z&WTK)tkJSjuT2P|L4W8DESFxY<6E>5ceWNI{xgQh)s>QoTsQ_dvU1P6z)i{7@wg8| z;9w*D8C#8Odav6|e6S?WnCE6|Ihsp)T&$}-p%^k)gYKT<$F;TZk&wg|*J3Aw26KAQ zrvY!Q`YKRws%!82jb7KSzBp@_T)QL^8a-O! zFDl-%KCPzdX>EzV8gXK_szS$N6bcuoCJwoWlWx&da?tv;U9l)WH^0?>WykfiZndva zKbI0&e#Y@{FC|WS0#3~qyZr)~9O9ViN0MNH21mD&Ly`deov#JaGTg4TvX!!5wLt-` zTl}Q&*w3y~+JbZJRN3;#S3Xz0kF+mi6_e$e06yRK4I5o{Kyn1$;$|4{)7rkG1~J6@ zeBz=&Fe}{|_z}R*f5`2EF+4X zP7XlX@#>9P6BC1S5!<&S7mzZ%68m5P(eE>k`1GhKxL$Yp689q*ktk}#?R?*8AT`=^ zJo9ZW^5PfK7M8{R%FXrjPLmV~IPamz^JLRw&X~DM7~nm&W0L(7{Wk^@7Do7~J9Sfg zDCpX?mk^8Ye$$}J=>?fW0L#c@=bq< zYo96Oa;;0Lxnd4Y+@{7_YoPZBDOdE|M06*o>F;DWHu~VrHRcGE0SxVo%+!?@JeQoh zI?1R|)qg&wG=G1U*%kQ50_pOV1ntbzDCpW_!-Is5`3)X-4pTs2VH?!oRp-&pWGw#6 z%mrdsd?DHn$kx4hATkEyCGnz@>rMdlYn(#xuNVmffZx?cwyXWftM$%Wco*rPP$Dxk zz{N_Of+V^SCa}C&dP>D%2^lVbbK$a(hu~Bm`dKH;Tym6 z&f-g@R!+x+sb8LAm}H;+DVU?B*sT;E+AeKYjFB~!Kt&J@zX36HzXi8A^-K!0bq|wU z;PP&sOeG_jT_$Bf#*RYsf23~_JNQ%z4B6eCj0=)RUd&t?)@W-k89?Nax|V31O&+|n z8&A%Ph?;rmO3seTbO!~v-3JXi@-oY_PTXD+zwUHoTWETg-p=J>pz9yspFiA?~(|+)BZz%B8;y9=$fQSppcpgM9!OiGP0F zA%JRJ*0VRmhz5kqEH`Nhwa)=^j?O0iEiTL1Zq#mkttR)q#iakDv|RQjaU`Q0g~m6I zT`nZ6co%O2wbn}OYZ`mF`bpjtoXSld(GCC?GIdVIG)al4bQxd1T2&>H5ZZ>a9Zq_2 zk1qt)XposrIQ^Y>TGf2^CGG>fp3665adTQmdndV-d%*gHi=A5b_Y0#h2Xs$P(|v<^ z0i{g0oLF|5=S_8X6Dn$6_#lnZEz-uz&F)qMlz)I)9shckQ;BOUS(Wd)#uce6rCVVU zzsvEUY90q4Ar;#k^_72%GvCgAkeVw^UDq}W1F%!Fj|Axv5vfrcTU}>8tL&y*8$DR1 zUp75-Ww%`}UU&t&Ta$kHvy#8fqFAu~rEPNp+tBf()*6;rVc13aEjC~d$QNxT8!t96 zTDV+XZ3uWVkFT}IGFKYksb4UK0!C#xAcd4)+GEzf(Vx=dp@)`@$VRV%J@XHp3M@8? z8q&us(G|CD_GTSge2@o`4K@$TCcpGB3buAM&5s%_+EygT$q4B(P_H^?k1P7tWP+00 zRexLQv6`znTI3F2KI<{RF<`CmfrZ`R9@-=n+aWQzY@Ki8^`$aJzf{8FJBY0@E!SgM7Qa_jK!UWU2OMlQ;hO4#g+1`lPL=GF-*s)^5nq{1jf) z|3>E7tzny0Gv;F|`fvJS#g#jbt*TPrA#&G%pbmEdhQw~dKjaTpm@JI+geYyUly3(^ zSlkCMt+#R%m27}jRD_^1%rqNLp8KM|=0OT4VmS7~ZSLps!o|r;M?F)s%Ut-Qu6O4Z zoW`BdhOi^vyKKnm23)1sq)NqE z-f6dL5Ttp!iB`$Z{Y%_mTPMFo&w|YFK2gK}Jr|P-H|ZUbeyEt&0t=b+@~Wg84|$jS z$4X^q>_MDfzx&+d(dfA&=|50YGMk2`0~5V(+kS_9oV)UfH{E2*l3bi`r6GSKZ@I&y ztulG+_8Bsg+tKmG(Qs-b7mALPh-xnwn7Ex52oF4@1)l(6D|mB|c20xn?I(I_XV$Fo zWDE@iTPi`4bG%F*7a%ozW^CHutD%k}wh=2uVN`Qd+VW~xA}@ma(wY7Jf9 z`BIA;8o zQVb|V@6;W-^($rWR-Xc`qp3wIyH(RGGtpS~)Q-PVk)GKnrfuk2t(UH-VH2a_TVCr6 z4cS*tc%9`VS~oqhSrU6~-uXmNw+GUt>q=y+Z2@W@_Vi31KXp`Hs6%^wmlGVtasF`z zy9Ciy$Z3H?YwlY7=wA$nC~x*KVEiTRFco>g-#J~Hvb8YAi+?eR Date: Thu, 7 Jul 2022 16:40:32 -0500 Subject: [PATCH 07/37] fix(depinject): move non-thread safe write (#12484) * fix(depinject): move non-thread safe write * remove whitespace * Push invoker descriptor mutation down one more layer Co-authored-by: Aleksandr Bezobchuk --- core/appmodule/option.go | 2 +- depinject/config.go | 2 +- depinject/container.go | 6 ------ depinject/provider_desc.go | 20 ++++++++++++++++++++ 4 files changed, 22 insertions(+), 8 deletions(-) diff --git a/core/appmodule/option.go b/core/appmodule/option.go index 53121e703ca5..c55201bfd37d 100644 --- a/core/appmodule/option.go +++ b/core/appmodule/option.go @@ -40,7 +40,7 @@ func Provide(providers ...interface{}) Option { func Invoke(invokers ...interface{}) Option { return funcOption(func(initializer *internal.ModuleInitializer) error { for _, invoker := range invokers { - desc, err := depinject.ExtractProviderDescriptor(invoker) + desc, err := depinject.ExtractInvokerDescriptor(invoker) if err != nil { return err } diff --git a/depinject/config.go b/depinject/config.go index 54deb9e8d2f2..0584c27b478a 100644 --- a/depinject/config.go +++ b/depinject/config.go @@ -75,7 +75,7 @@ func InvokeInModule(moduleName string, invokers ...interface{}) Config { func invoke(ctr *container, key *moduleKey, invokers []interface{}) error { for _, c := range invokers { - rc, err := ExtractProviderDescriptor(c) + rc, err := ExtractInvokerDescriptor(c) if err != nil { return errors.WithStack(err) } diff --git a/depinject/container.go b/depinject/container.go index 08fa30363b10..189405ece462 100644 --- a/depinject/container.go +++ b/depinject/container.go @@ -365,12 +365,6 @@ func (c *container) addInvoker(provider *ProviderDescriptor, key *moduleKey) err return fmt.Errorf("invoker function %s should not return any outputs", provider.Location) } - // make all inputs optional - for i, input := range provider.Inputs { - input.Optional = true - provider.Inputs[i] = input - } - c.invokers = append(c.invokers, invoker{ fn: provider, modKey: key, diff --git a/depinject/provider_desc.go b/depinject/provider_desc.go index bf39e2a31873..16a8f3c7972f 100644 --- a/depinject/provider_desc.go +++ b/depinject/provider_desc.go @@ -47,6 +47,26 @@ func ExtractProviderDescriptor(provider interface{}) (ProviderDescriptor, error) return expandStructArgsProvider(rctr) } +func ExtractInvokerDescriptor(provider interface{}) (ProviderDescriptor, error) { + rctr, ok := provider.(ProviderDescriptor) + if !ok { + var err error + rctr, err = doExtractProviderDescriptor(provider) + + // mark all inputs as optional + for i, input := range rctr.Inputs { + input.Optional = true + rctr.Inputs[i] = input + } + + if err != nil { + return ProviderDescriptor{}, err + } + } + + return expandStructArgsProvider(rctr) +} + func doExtractProviderDescriptor(ctr interface{}) (ProviderDescriptor, error) { val := reflect.ValueOf(ctr) typ := val.Type() From 36ffd7a6daa6fdc324d0588dde168f930a11730e Mon Sep 17 00:00:00 2001 From: Matt Kocubinski Date: Fri, 8 Jul 2022 00:44:01 -0500 Subject: [PATCH 08/37] refactor(x/params): use mocks for testing (#12473) * remove dependency on simapp from x/params keeper tests * refactor x/params proposal_handler_test away from simapp * update mockgen * import ordering * more import ordering --- scripts/mockgen.sh | 3 +- x/params/keeper/keeper_test.go | 24 ++++++------ x/params/proposal_handler_test.go | 29 ++++++++------ x/params/testutil/staking_keeper_mock.go | 49 ++++++++++++++++++++++++ 4 files changed, 80 insertions(+), 25 deletions(-) create mode 100644 x/params/testutil/staking_keeper_mock.go diff --git a/scripts/mockgen.sh b/scripts/mockgen.sh index 15ff219d0b38..3894393a801c 100755 --- a/scripts/mockgen.sh +++ b/scripts/mockgen.sh @@ -10,4 +10,5 @@ $mockgen_cmd -source=types/router.go -package mocks -destination tests/mocks/typ $mockgen_cmd -package mocks -destination tests/mocks/grpc_server.go github.com/gogo/protobuf/grpc Server $mockgen_cmd -package mocks -destination tests/mocks/tendermint_tendermint_libs_log_DB.go github.com/tendermint/tendermint/libs/log Logger $mockgen_cmd -source=orm/model/ormtable/hooks.go -package ormmocks -destination orm/testing/ormmocks/hooks.go -$mockgen_cmd -source=x/nft/expected_keepers.go -package testutil -destination x/nft/testutil/expected_keepers_mocks.go \ No newline at end of file +$mockgen_cmd -source=x/nft/expected_keepers.go -package testutil -destination x/nft/testutil/expected_keepers_mocks.go +$mockgen_cmd -source=x/params/proposal_handler_test.go -package testutil -destination x/params/testutil/staking_keeper_mock.go \ No newline at end of file diff --git a/x/params/keeper/keeper_test.go b/x/params/keeper/keeper_test.go index 7183cdf9d8ac..6a7b32e657a0 100644 --- a/x/params/keeper/keeper_test.go +++ b/x/params/keeper/keeper_test.go @@ -6,15 +6,14 @@ import ( "github.com/stretchr/testify/require" "github.com/stretchr/testify/suite" - tmproto "github.com/tendermint/tendermint/proto/tendermint/types" "github.com/cosmos/cosmos-sdk/baseapp" - codectypes "github.com/cosmos/cosmos-sdk/codec/types" "github.com/cosmos/cosmos-sdk/store/prefix" - simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims" + "github.com/cosmos/cosmos-sdk/testutil" sdk "github.com/cosmos/cosmos-sdk/types" + moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil" + "github.com/cosmos/cosmos-sdk/x/params" "github.com/cosmos/cosmos-sdk/x/params/keeper" - "github.com/cosmos/cosmos-sdk/x/params/testutil" "github.com/cosmos/cosmos-sdk/x/params/types" "github.com/cosmos/cosmos-sdk/x/params/types/proposal" ) @@ -28,17 +27,18 @@ type KeeperTestSuite struct { } func (suite *KeeperTestSuite) SetupTest() { - var interfaceRegistry codectypes.InterfaceRegistry + encodingCfg := moduletestutil.MakeTestEncodingConfig(params.AppModuleBasic{}) + key := sdk.NewKVStoreKey(types.StoreKey) + tkey := sdk.NewTransientStoreKey("params_transient_test") - app, err := simtestutil.Setup( - testutil.AppConfig, - &suite.paramsKeeper, - ) - suite.Require().NoError(err) + suite.ctx = testutil.DefaultContext(key, tkey) + suite.paramsKeeper = keeper.NewKeeper(encodingCfg.Codec, encodingCfg.Amino, key, tkey) + suite.paramsKeeper.Subspace("bank") + suite.paramsKeeper.Subspace("staking") - suite.ctx = app.BaseApp.NewContext(false, tmproto.Header{}) - queryHelper := baseapp.NewQueryServerTestHelper(suite.ctx, interfaceRegistry) + queryHelper := baseapp.NewQueryServerTestHelper(suite.ctx, encodingCfg.InterfaceRegistry) proposal.RegisterQueryServer(queryHelper, suite.paramsKeeper) + suite.queryClient = proposal.NewQueryClient(queryHelper) } diff --git a/x/params/proposal_handler_test.go b/x/params/proposal_handler_test.go index cead833638b9..3d9a6b6a1dd5 100644 --- a/x/params/proposal_handler_test.go +++ b/x/params/proposal_handler_test.go @@ -3,16 +3,17 @@ package params_test import ( "testing" + "github.com/golang/mock/gomock" "github.com/stretchr/testify/suite" - tmproto "github.com/tendermint/tendermint/proto/tendermint/types" - - simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims" + "github.com/cosmos/cosmos-sdk/testutil" sdk "github.com/cosmos/cosmos-sdk/types" + moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil" govv1beta1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1beta1" "github.com/cosmos/cosmos-sdk/x/params" "github.com/cosmos/cosmos-sdk/x/params/keeper" - "github.com/cosmos/cosmos-sdk/x/params/testutil" + paramstestutil "github.com/cosmos/cosmos-sdk/x/params/testutil" + paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" "github.com/cosmos/cosmos-sdk/x/params/types/proposal" stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" ) @@ -31,16 +32,20 @@ type HandlerTestSuite struct { } func (suite *HandlerTestSuite) SetupTest() { - var paramsKeeper keeper.Keeper - app, err := simtestutil.Setup( - testutil.AppConfig, - ¶msKeeper, - &suite.stakingKeeper, - ) - suite.Require().NoError(err) + encodingCfg := moduletestutil.MakeTestEncodingConfig(params.AppModuleBasic{}) + key := sdk.NewKVStoreKey(paramtypes.StoreKey) + tkey := sdk.NewTransientStoreKey("params_transient_test") + + ctx := testutil.DefaultContext(key, tkey) + paramsKeeper := keeper.NewKeeper(encodingCfg.Codec, encodingCfg.Amino, key, tkey) + paramsKeeper.Subspace("staking").WithKeyTable(stakingtypes.ParamKeyTable()) + ctrl := gomock.NewController(suite.T()) + stakingKeeper := paramstestutil.NewMockStakingKeeper(ctrl) + stakingKeeper.EXPECT().MaxValidators(ctx).Return(uint32(1)) - suite.ctx = app.BaseApp.NewContext(false, tmproto.Header{}) suite.govHandler = params.NewParamChangeProposalHandler(paramsKeeper) + suite.stakingKeeper = stakingKeeper + suite.ctx = ctx } func TestHandlerTestSuite(t *testing.T) { diff --git a/x/params/testutil/staking_keeper_mock.go b/x/params/testutil/staking_keeper_mock.go new file mode 100644 index 000000000000..a90f80ad43ae --- /dev/null +++ b/x/params/testutil/staking_keeper_mock.go @@ -0,0 +1,49 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: x/params/proposal_handler_test.go + +// Package testutil is a generated GoMock package. +package testutil + +import ( + reflect "reflect" + + types "github.com/cosmos/cosmos-sdk/types" + gomock "github.com/golang/mock/gomock" +) + +// MockStakingKeeper is a mock of StakingKeeper interface. +type MockStakingKeeper struct { + ctrl *gomock.Controller + recorder *MockStakingKeeperMockRecorder +} + +// MockStakingKeeperMockRecorder is the mock recorder for MockStakingKeeper. +type MockStakingKeeperMockRecorder struct { + mock *MockStakingKeeper +} + +// NewMockStakingKeeper creates a new mock instance. +func NewMockStakingKeeper(ctrl *gomock.Controller) *MockStakingKeeper { + mock := &MockStakingKeeper{ctrl: ctrl} + mock.recorder = &MockStakingKeeperMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockStakingKeeper) EXPECT() *MockStakingKeeperMockRecorder { + return m.recorder +} + +// MaxValidators mocks base method. +func (m *MockStakingKeeper) MaxValidators(ctx types.Context) uint32 { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "MaxValidators", ctx) + ret0, _ := ret[0].(uint32) + return ret0 +} + +// MaxValidators indicates an expected call of MaxValidators. +func (mr *MockStakingKeeperMockRecorder) MaxValidators(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MaxValidators", reflect.TypeOf((*MockStakingKeeper)(nil).MaxValidators), ctx) +} From 69d8fa2bafa2c5ca5b8f1fd91ef379cec0b07d03 Mon Sep 17 00:00:00 2001 From: Aleksandr Bezobchuk Date: Fri, 8 Jul 2022 02:38:18 -0400 Subject: [PATCH 09/37] chore: params cleanup (#12480) Adds missing error checks to the modules that migrated away from `x/params` --- x/distribution/module.go | 11 +++++------ x/gov/module.go | 18 +++++++++--------- x/mint/keeper/genesis.go | 6 +++++- x/slashing/keeper/genesis.go | 4 +++- x/staking/module.go | 14 ++++++-------- 5 files changed, 28 insertions(+), 25 deletions(-) diff --git a/x/distribution/module.go b/x/distribution/module.go index 91a058f1aa61..c303b2712e44 100644 --- a/x/distribution/module.go +++ b/x/distribution/module.go @@ -4,14 +4,14 @@ import ( "context" "encoding/json" "fmt" - govv1beta1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1beta1" "math/rand" + modulev1 "cosmossdk.io/api/cosmos/distribution/module/v1" + "cosmossdk.io/core/appmodule" gwruntime "github.com/grpc-ecosystem/grpc-gateway/runtime" "github.com/spf13/cobra" abci "github.com/tendermint/tendermint/abci/types" - "cosmossdk.io/core/appmodule" sdkclient "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/codec" cdctypes "github.com/cosmos/cosmos-sdk/codec/types" @@ -22,14 +22,13 @@ import ( "github.com/cosmos/cosmos-sdk/types/module" simtypes "github.com/cosmos/cosmos-sdk/types/simulation" authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" - paramstypes "github.com/cosmos/cosmos-sdk/x/params/types" - staking "github.com/cosmos/cosmos-sdk/x/staking/types" - - modulev1 "cosmossdk.io/api/cosmos/distribution/module/v1" "github.com/cosmos/cosmos-sdk/x/distribution/client/cli" "github.com/cosmos/cosmos-sdk/x/distribution/keeper" "github.com/cosmos/cosmos-sdk/x/distribution/simulation" "github.com/cosmos/cosmos-sdk/x/distribution/types" + govv1beta1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1beta1" + paramstypes "github.com/cosmos/cosmos-sdk/x/params/types" + staking "github.com/cosmos/cosmos-sdk/x/staking/types" ) var ( diff --git a/x/gov/module.go b/x/gov/module.go index edef90247130..2147096a39ff 100644 --- a/x/gov/module.go +++ b/x/gov/module.go @@ -4,27 +4,26 @@ package gov import ( "context" - modulev1 "cosmossdk.io/api/cosmos/gov/module/v1" - "cosmossdk.io/core/appmodule" "encoding/json" "fmt" - "github.com/cosmos/cosmos-sdk/baseapp" - "github.com/cosmos/cosmos-sdk/depinject" - "github.com/cosmos/cosmos-sdk/runtime" - store "github.com/cosmos/cosmos-sdk/store/types" - paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" - "golang.org/x/exp/maps" - "golang.org/x/exp/slices" "math/rand" "sort" + modulev1 "cosmossdk.io/api/cosmos/gov/module/v1" + "cosmossdk.io/core/appmodule" gwruntime "github.com/grpc-ecosystem/grpc-gateway/runtime" "github.com/spf13/cobra" abci "github.com/tendermint/tendermint/abci/types" + "golang.org/x/exp/maps" + "golang.org/x/exp/slices" + "github.com/cosmos/cosmos-sdk/baseapp" "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/codec" codectypes "github.com/cosmos/cosmos-sdk/codec/types" + "github.com/cosmos/cosmos-sdk/depinject" + "github.com/cosmos/cosmos-sdk/runtime" + store "github.com/cosmos/cosmos-sdk/store/types" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/module" simtypes "github.com/cosmos/cosmos-sdk/types/simulation" @@ -35,6 +34,7 @@ import ( "github.com/cosmos/cosmos-sdk/x/gov/types" v1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1" "github.com/cosmos/cosmos-sdk/x/gov/types/v1beta1" + paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" ) var ( diff --git a/x/mint/keeper/genesis.go b/x/mint/keeper/genesis.go index c6a120bee7fe..ce0d9361b7cf 100644 --- a/x/mint/keeper/genesis.go +++ b/x/mint/keeper/genesis.go @@ -8,7 +8,11 @@ import ( // InitGenesis new mint genesis func (keeper Keeper) InitGenesis(ctx sdk.Context, ak types.AccountKeeper, data *types.GenesisState) { keeper.SetMinter(ctx, data.Minter) - keeper.SetParams(ctx, data.Params) + + if err := keeper.SetParams(ctx, data.Params); err != nil { + panic(err) + } + ak.GetModuleAccount(ctx, types.ModuleName) } diff --git a/x/slashing/keeper/genesis.go b/x/slashing/keeper/genesis.go index 469947ed38f1..e53ef3730c06 100644 --- a/x/slashing/keeper/genesis.go +++ b/x/slashing/keeper/genesis.go @@ -38,7 +38,9 @@ func (keeper Keeper) InitGenesis(ctx sdk.Context, stakingKeeper types.StakingKee } } - keeper.SetParams(ctx, data.Params) + if err := keeper.SetParams(ctx, data.Params); err != nil { + panic(err) + } } // ExportGenesis writes the current store values diff --git a/x/staking/module.go b/x/staking/module.go index 4bbbf2d05cfb..944d7d4842f8 100644 --- a/x/staking/module.go +++ b/x/staking/module.go @@ -7,25 +7,23 @@ import ( "math/rand" "sort" - gwruntime "github.com/grpc-ecosystem/grpc-gateway/runtime" - "golang.org/x/exp/maps" - modulev1 "cosmossdk.io/api/cosmos/staking/module/v1" "cosmossdk.io/core/appmodule" - "github.com/cosmos/cosmos-sdk/depinject" - "github.com/cosmos/cosmos-sdk/runtime" - store "github.com/cosmos/cosmos-sdk/store/types" - paramstypes "github.com/cosmos/cosmos-sdk/x/params/types" - + gwruntime "github.com/grpc-ecosystem/grpc-gateway/runtime" "github.com/spf13/cobra" abci "github.com/tendermint/tendermint/abci/types" + "golang.org/x/exp/maps" "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/codec" cdctypes "github.com/cosmos/cosmos-sdk/codec/types" + "github.com/cosmos/cosmos-sdk/depinject" + "github.com/cosmos/cosmos-sdk/runtime" + store "github.com/cosmos/cosmos-sdk/store/types" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/module" simtypes "github.com/cosmos/cosmos-sdk/types/simulation" + paramstypes "github.com/cosmos/cosmos-sdk/x/params/types" "github.com/cosmos/cosmos-sdk/x/staking/client/cli" "github.com/cosmos/cosmos-sdk/x/staking/keeper" "github.com/cosmos/cosmos-sdk/x/staking/simulation" From fd7cdd6b7ab6b29be2abd4ad263d49b876ef851f Mon Sep 17 00:00:00 2001 From: Deepto Date: Fri, 8 Jul 2022 12:37:58 +0530 Subject: [PATCH 10/37] fix: removed deprecated sdk.DBBackend variable (#12355) ## Description Closes: #11410 #11241 --- ### Author Checklist *All items are required. Please add a note to the item if the item is not applicable and please add links to any relevant follow up issues.* I have... - [ ] included the correct [type prefix](https://github.com/commitizen/conventional-commit-types/blob/v3.0.0/index.json) in the PR title - [ ] added `!` to the type prefix if API or client breaking change - [ ] targeted the correct branch (see [PR Targeting](https://github.com/cosmos/cosmos-sdk/blob/main/CONTRIBUTING.md#pr-targeting)) - [ ] provided a link to the relevant issue or specification - [ ] followed the guidelines for [building modules](https://github.com/cosmos/cosmos-sdk/blob/main/docs/building-modules) - [ ] included the necessary unit and integration [tests](https://github.com/cosmos/cosmos-sdk/blob/main/CONTRIBUTING.md#testing) - [ ] added a changelog entry to `CHANGELOG.md` - [ ] included comments for [documenting Go code](https://blog.golang.org/godoc) - [ ] updated the relevant documentation or specification - [ ] reviewed "Files changed" and left comments if necessary - [ ] confirmed all CI checks have passed ### Reviewers Checklist *All items are required. Please add a note if the item is not applicable and please add your handle next to the items reviewed if you only reviewed selected items.* I have... - [ ] confirmed the correct [type prefix](https://github.com/commitizen/conventional-commit-types/blob/v3.0.0/index.json) in the PR title - [ ] confirmed `!` in the type prefix if API or client breaking change - [ ] confirmed all author checklist items have been addressed - [ ] reviewed state machine logic - [ ] reviewed API design and naming - [ ] reviewed documentation is accurate - [ ] reviewed tests and test coverage - [ ] manually tested (if applicable) --- CHANGELOG.md | 4 +++ server/util.go | 4 +-- server/util_test.go | 76 --------------------------------------------- types/utils.go | 9 +----- 4 files changed, 6 insertions(+), 87 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 6174a6eda918..b0f29ae9ef19 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -37,6 +37,10 @@ Ref: https://keepachangelog.com/en/1.0.0/ ## [Unreleased] + +### API Breaking Changes + +* (types) [\#12355](https://github.com/cosmos/cosmos-sdk/pull/12355) Remove the compile-time `types.DBbackend` variable. Removes usage of the same in server/util.go ### Features * (cli) [#12028](https://github.com/cosmos/cosmos-sdk/pull/12028) Add the `tendermint key-migrate` to perform Tendermint v0.35 DB key migration. diff --git a/server/util.go b/server/util.go index a201442025a1..ed0d8db04f60 100644 --- a/server/util.go +++ b/server/util.go @@ -365,9 +365,7 @@ func WaitForQuitSignals() ErrorCode { // GetAppDBBackend gets the backend type to use for the application DBs. func GetAppDBBackend(opts types.AppOptions) dbm.BackendType { rv := cast.ToString(opts.Get("app-db-backend")) - if len(rv) == 0 { - rv = sdk.DBBackend - } + if len(rv) == 0 { rv = cast.ToString(opts.Get("db-backend")) } diff --git a/server/util_test.go b/server/util_test.go index 37e23e8d5f94..c3bd0f9063cd 100644 --- a/server/util_test.go +++ b/server/util_test.go @@ -11,10 +11,8 @@ import ( "testing" "github.com/spf13/cobra" - "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" tmcfg "github.com/tendermint/tendermint/config" - dbm "github.com/tendermint/tm-db" "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/client/flags" @@ -22,7 +20,6 @@ import ( "github.com/cosmos/cosmos-sdk/server/config" servertypes "github.com/cosmos/cosmos-sdk/server/types" "github.com/cosmos/cosmos-sdk/simapp" - "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" genutilcli "github.com/cosmos/cosmos-sdk/x/genutil/client/cli" ) @@ -450,76 +447,3 @@ func (m mapGetter) Get(key string) interface{} { } var _ servertypes.AppOptions = mapGetter{} - -func TestGetAppDBBackend(t *testing.T) { - origDBBackend := types.DBBackend - defer func() { - types.DBBackend = origDBBackend - }() - tests := []struct { - name string - dbBack string - opts mapGetter - exp dbm.BackendType - }{ - { - name: "nothing set", - dbBack: "", - opts: mapGetter{}, - exp: dbm.GoLevelDBBackend, - }, - - { - name: "only db-backend set", - dbBack: "", - opts: mapGetter{"db-backend": "db-backend value 1"}, - exp: dbm.BackendType("db-backend value 1"), - }, - { - name: "only DBBackend set", - dbBack: "DBBackend value 2", - opts: mapGetter{}, - exp: dbm.BackendType("DBBackend value 2"), - }, - { - name: "only app-db-backend set", - dbBack: "", - opts: mapGetter{"app-db-backend": "app-db-backend value 3"}, - exp: dbm.BackendType("app-db-backend value 3"), - }, - - { - name: "app-db-backend and db-backend set", - dbBack: "", - opts: mapGetter{"db-backend": "db-backend value 4", "app-db-backend": "app-db-backend value 5"}, - exp: dbm.BackendType("app-db-backend value 5"), - }, - { - name: "app-db-backend and DBBackend set", - dbBack: "DBBackend value 6", - opts: mapGetter{"app-db-backend": "app-db-backend value 7"}, - exp: dbm.BackendType("app-db-backend value 7"), - }, - { - name: "db-backend and DBBackend set", - dbBack: "DBBackend value 8", - opts: mapGetter{"db-backend": "db-backend value 9"}, - exp: dbm.BackendType("DBBackend value 8"), - }, - - { - name: "all of app-db-backend db-backend DBBackend set", - dbBack: "DBBackend value 10", - opts: mapGetter{"db-backend": "db-backend value 11", "app-db-backend": "app-db-backend value 12"}, - exp: dbm.BackendType("app-db-backend value 12"), - }, - } - - for _, tc := range tests { - t.Run(tc.name, func(st *testing.T) { - types.DBBackend = tc.dbBack - act := server.GetAppDBBackend(tc.opts) - assert.Equal(st, tc.exp, act) - }) - } -} diff --git a/types/utils.go b/types/utils.go index 50074f2b052d..7f10ce396c86 100644 --- a/types/utils.go +++ b/types/utils.go @@ -12,16 +12,9 @@ import ( var ( // This is set at compile time. Could be cleveldb, defaults is goleveldb. - DBBackend = "" // Deprecated: Use tendermint config's DBBackend value instead. - backend = dbm.GoLevelDBBackend + backend = dbm.GoLevelDBBackend ) -func init() { - if len(DBBackend) != 0 { - backend = dbm.BackendType(DBBackend) - } -} - // SortedJSON takes any JSON and returns it sorted by keys. Also, all white-spaces // are removed. // This method can be used to canonicalize JSON to be returned by GetSignBytes, From 0bf30983fb0fc75441b71ec9768edd5383f0ebe5 Mon Sep 17 00:00:00 2001 From: Cian Hatton Date: Fri, 8 Jul 2022 08:28:34 +0100 Subject: [PATCH 11/37] feat: Support providing custom keyring for keystore. (#12453) ## Description Closes: #12438 --- ### Author Checklist *All items are required. Please add a note to the item if the item is not applicable and please add links to any relevant follow up issues.* I have... - [X] included the correct [type prefix](https://github.com/commitizen/conventional-commit-types/blob/v3.0.0/index.json) in the PR title - [X] added `!` to the type prefix if API or client breaking change - [x] targeted the correct branch (see [PR Targeting](https://github.com/cosmos/cosmos-sdk/blob/main/CONTRIBUTING.md#pr-targeting)) - [x] provided a link to the relevant issue or specification - [x] followed the guidelines for [building modules](https://github.com/cosmos/cosmos-sdk/blob/main/docs/building-modules) - [x] included the necessary unit and integration [tests](https://github.com/cosmos/cosmos-sdk/blob/main/CONTRIBUTING.md#testing) - [x] added a changelog entry to `CHANGELOG.md` - [x] included comments for [documenting Go code](https://blog.golang.org/godoc) - [ ] updated the relevant documentation or specification - [x] reviewed "Files changed" and left comments if necessary - [ ] confirmed all CI checks have passed ### Reviewers Checklist *All items are required. Please add a note if the item is not applicable and please add your handle next to the items reviewed if you only reviewed selected items.* I have... - [ ] confirmed the correct [type prefix](https://github.com/commitizen/conventional-commit-types/blob/v3.0.0/index.json) in the PR title - [ ] confirmed `!` in the type prefix if API or client breaking change - [ ] confirmed all author checklist items have been addressed - [ ] reviewed state machine logic - [ ] reviewed API design and naming - [ ] reviewed documentation is accurate - [ ] reviewed tests and test coverage - [ ] manually tested (if applicable) --- CHANGELOG.md | 1 + crypto/keyring/keyring.go | 8 ++++++- crypto/keyring/keyring_test.go | 44 ++++++++++++++++++++++++++++++++++ 3 files changed, 52 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index b0f29ae9ef19..d7f7c5e1e483 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -52,6 +52,7 @@ Ref: https://keepachangelog.com/en/1.0.0/ * [#12089](https://github.com/cosmos/cosmos-sdk/pull/12089) Mark the `TipDecorator` as beta, don't include it in simapp by default. * [#12153](https://github.com/cosmos/cosmos-sdk/pull/12153) Add a new `NewSimulationManagerFromAppModules` constructor, to simplify simulation wiring. * [#12187](https://github.com/cosmos/cosmos-sdk/pull/12187) Add batch operation for x/nft module. +* [#12453](https://github.com/cosmos/cosmos-sdk/pull/12453) Add `NewInMemoryWithKeyring` function which allows the creation of in memory `keystore` instances with a specified set of existing items. ### State Machine Breaking diff --git a/crypto/keyring/keyring.go b/crypto/keyring/keyring.go index 5434a27eed62..370e0111cec4 100644 --- a/crypto/keyring/keyring.go +++ b/crypto/keyring/keyring.go @@ -150,7 +150,13 @@ type Options struct { // purposes and on-the-fly key generation. // Keybase options can be applied when generating this new Keybase. func NewInMemory(cdc codec.Codec, opts ...Option) Keyring { - return newKeystore(keyring.NewArrayKeyring(nil), cdc, BackendMemory, opts...) + return NewInMemoryWithKeyring(keyring.NewArrayKeyring(nil), cdc, opts...) +} + +// NewInMemoryWithKeyring returns an in memory keyring using the specified keyring.Keyring +// as the backing keyring. +func NewInMemoryWithKeyring(kr keyring.Keyring, cdc codec.Codec, opts ...Option) Keyring { + return newKeystore(kr, cdc, BackendMemory, opts...) } // New creates a new instance of a keyring. diff --git a/crypto/keyring/keyring_test.go b/crypto/keyring/keyring_test.go index 66c326598b71..e2d994187752 100644 --- a/crypto/keyring/keyring_test.go +++ b/crypto/keyring/keyring_test.go @@ -21,6 +21,7 @@ import ( "github.com/cosmos/cosmos-sdk/crypto/keys/multisig" "github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1" "github.com/cosmos/cosmos-sdk/crypto/types" + cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types" sdk "github.com/cosmos/cosmos-sdk/types" ) @@ -455,6 +456,49 @@ func TestInMemoryLanguage(t *testing.T) { require.Equal(t, "unsupported language: only english is supported", err.Error()) } +func TestInMemoryWithKeyring(t *testing.T) { + priv := cryptotypes.PrivKey(secp256k1.GenPrivKey()) + pub := priv.PubKey() + + cdc := getCodec() + _, err := NewLocalRecord("test record", priv, pub) + + multi := multisig.NewLegacyAminoPubKey( + 1, []cryptotypes.PubKey{ + pub, + }, + ) + + appName := "test-app" + + legacyMultiInfo, err := NewLegacyMultiInfo(appName, multi) + require.NoError(t, err) + serializedLegacyMultiInfo := MarshalInfo(legacyMultiInfo) + + kb := NewInMemoryWithKeyring(keyring.NewArrayKeyring([]keyring.Item{ + { + Key: appName + ".info", + Data: serializedLegacyMultiInfo, + Description: "test description", + }, + }), cdc) + + t.Run("key exists", func(t *testing.T) { + _, err := kb.Key(appName) + require.NoError(t, err) + }) + + t.Run("key deleted", func(t *testing.T) { + err := kb.Delete(appName) + require.NoError(t, err) + + t.Run("key is gone", func(t *testing.T) { + _, err := kb.Key(appName) + require.Error(t, err) + }) + }) +} + func TestInMemoryCreateMultisig(t *testing.T) { cdc := getCodec() kb, err := New("keybasename", "memory", "", nil, cdc) From ae67d2b0a3670adbae14d111f79259a19fb30600 Mon Sep 17 00:00:00 2001 From: Aaron Craelius Date: Fri, 8 Jul 2022 10:01:03 +0200 Subject: [PATCH 12/37] docs: add app module wiring how to (#12382) * docs: add app module wiring how to * WIP * WIP * beautify and fix comment Co-authored-by: Julien Robert --- core/appmodule/README.md | 232 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 232 insertions(+) create mode 100644 core/appmodule/README.md diff --git a/core/appmodule/README.md b/core/appmodule/README.md new file mode 100644 index 000000000000..0348e5266970 --- /dev/null +++ b/core/appmodule/README.md @@ -0,0 +1,232 @@ +# Wiring up app modules for use with appconfig + +The `appconfig` framework allows Cosmos SDK modules to be composed declaratively using a configuration file without +requiring the app developer to understand the details of inter-module dependencies. + +## 1. Create a module config protobuf message + +The first step in creating a module that works with `appconfig`, is to create a protobuf message for the module configuration. The best practices for defining the module configuration message are: + +* Use a dedicated protobuf package for the module configuration message instead of placing it in the API protobuf package. For example, the module configuration for bank would go in `cosmos.bank.module.v1` instead of just `cosmos.bank.v1`. This decouples the state machine version from the API version. +* The module configuration message is usually called simply `Module`, ex. `cosmos.bank.module.v1.Module`. +* Create a new protobuf package and configuration message for each state machine breaking version of the module, ex. `cosmos.bank.module.v2.Module`, etc. + +The module configuration message should include any parameters which should be initialized at application startup. For example, the auth module needs to know the bech32 prefix of the app and the permissions of module accounts. + +In the future, it may be possible to update the app config through a governance proposal at runtime. + +All module configuration messages should define a module descriptor, using the `cosmos.app.v1alpha1.module` message option. + +Here is an example module configuration message for the `auth` module: + +```protobuf +package cosmos.auth.module.v1; + +import "cosmos/app/v1alpha1/module.proto"; + +message Module { + option (cosmos.app.v1alpha1.module) = { + go_import: "github.com/cosmos/cosmos-sdk/x/auth" + }; + string bech32_prefix = 1; + repeated ModuleAccountPermission module_account_permissions = 2; +} +``` + +## 2. Register module depinject providers and invokers + +Once we have a module config object, we need to register depinject providers and invokers for the module using the `cosmossdk.io/core/appmodule` package. + +At the most basic level, we must define an `init` function in the package listed as the `go_import` in the module descriptor. This `init` function must call `appmodule.Register` with an empty instance of the config object and some options for initializing the module, ex: + +```go +func init() { + appmodule.Register(&modulev1.Module{}, + // options + ) +} +``` + +### `depinject` Provider and Invoker Basics + +A `depinject` "provider" is a function which takes dependencies from other modules as inputs and returns outputs for +other modules to use as dependencies. A `depinject` "invoker" is function which takes optional dependencies as inputs, +returns no outputs, and is run at the end of initializing the dependency graph. Providers are much more common than +invokers and should be the preferred method of wiring up modules when possible. Providers and invokers can be registered +for modules by using `appmodule.Provide` and `appmodule.Invoke` to create options which get passed +to `appmodule.Register` in the module `init` function, ex: + +```go +func init() { + appmodule.Register(&modulev1.Module{}, + appmodule.Provide(provideSomething, provideSomethingElse), + appmodule.Invoke(invokeSomething), + ) +} +``` + +### `depinject` Types + +`depinject` constructor functions support these classes of input and output parameter types: + +* regular golang types (with special treatment of interface types as input parameters) +* structs with `depinject.In` and `depinject.Out` embedded +* `depinject.OnePerModuleType`s +* `depinject.ManyPerContainerType`s +* `depinject.ModuleKey` (which can only be defined as an input type) +* `error` (which gets special treatment as an output type) + +#### Regular Golang Types + +Regular golang types (besides the special cases described above) can be provided as both input and output parameters +to providers and invokers. For `depinject` to match an output parameter of one provider to an input parameter of +another, there must be an exact match for the type unless the input parameter is an input type. For instance, if +a provider defines a dependency on `Foo` and some module provides `*Foo`, these two types will not match and there +will be an error. + +#### Interface Input Types + +When interfaces are used as input parameters to providers and invokers, `depinject` will search the container for +all types that implement this interface. If there is an unambiguously matching type, then this type will be used +to satisfy that interface. If there is a conflict between two types matching the interface, the app developer +can use `golang_bindings` options in their app config in order to resolve the conflict. + +#### Structs with embedded `depinject.In` and `depinject.Out` + +Structs that have `depinject.In` or `depinject.Out` as an embedded field are treated specially by `depinject`, where +all of these structs fields are treated as input or output parameters, respectively. These structs allow custom options +to be defined using struct field tags. Currently, the only supported custom option is `optional:"true"` which marks +a field as optional. + +#### `depinject.OnePerModuleType`s + +Any type which implements the `depinject.OnePerModuleType` interface can be provided at most once by every module. +These types can be collected as an input parameter to some provider or invoker by defining an input parameter which +is a map of module names as strings to this parameter type. For example if `Foo` is a `OnePerModuleType`, then +`map[string]Foo` can be declared as an input parameter by some provider (which obviously cannot provide an instance of +`Foo` itself because that would cause a circular dependency). + +`OnePerModuleType`s should be used whenever different modules may provide the type *and* there is a need to provide +an ordering of these types based on the module name. Generally, in blockchains there is always a need for deterministic +orderings so using module names to provide that ordering is generally a good strategy for this use case. Ordering based +on module names can either be done implicitly by sorting the module names or explicitly as a parameter in the module +configuration object. + +#### `depinject.ManyPerContainerType`s + +`ManyPerContainerType`s can be provided by as many providers in as many modules as the user would like. If a type `Bar` +is a `ManyPerContainerType`, a provider may define an output parameter of `Bar` or `[]Bar` to provide `Bar` instances +to the container. A provider may define an input parameter of `[]Bar` to get all of the `Bar` instances in the +container (such a provider may not also return `Bar` as that would cause a circular dependency). The ordering of `Bar` +instances in the `[]Bar` input type should be assumed to be deterministic. + +`ManyPerContainerType`s should be used only when 1) ordering is unimportant or 2) the ordering can be defined by +some parameter on the type. For instance, if `Bar` had a field `Name string`, that is supposed to be unique in the +container then that could be used to provide an ordering. An example of a type that could work as a +`ManyPerContainerType` in this way is a wrapper around `*cobra.Command`, ex. +`type QueryCommand struct {*cobra.Command}`. This could be used to collect all the query commands in an app and then +cobra would take care of ordering. If this type of ordering is not available, a `OnePerModuleType` is probably a better +bet. + +#### Module-scoped Providers/`depinject.ModuleKey` as an input + +If `depinject.ModuleKey` is used as input parameter for a provider, the provider function will be treated as a +"module-scoped provider" which means that the provider function will be called exactly once every time +one of its outputs is needed by a module so that the provider can provide a unique instance of the dependency to +each module. + +Module-scoped dependencies should be used to provide dependencies which are private and unique to each module. Examples +of these are store keys and param subspaces. + +#### `error` as an output parameter + +`error` can be used as the last output parameter on any provider or invoker. If a provider or invoker with an `error` +parameter returns a non-nil value for `error`, `depinject` will fail and propagate this error up to the caller. + +### Provider Invocation Details + +Providers are called lazily as they are needed and will be invoked at most once (except for "module-scoped providers" +described above) if and only if at least one of their outputs is needed somewhere in the dependency graph. Providers +will only get called if all of their non-optional inputs can successfully be resolved by some other module, otherwise an +error will occur. Modules should proactively mark dependencies as `optional` if the module can still be successfully +built without this dependency. + +### Invoker Invocation Details + +Invokers are called at the end of container initialization after all providers that were needed to build the graph +were called. All the dependencies of invokers are automatically marked as optional so invokers should `nil` check +every input parameter. Invokers may cause additional providers to get run if they have a dependency that wasn't built +yet. But if a dependency to an invoker cannot be provided for some reason, the invoker will still get called but with +`nil` for that input. This allows invokers to still work with the lazy invocation model of providers which only +builds things which are actually necessary as a dependency for some module or the caller. + +Invokers should generally be used sparingly to perform some initialization logic which can't be done in the initial +provider, usually because of a circular dependency, and which may be optional. + +### Best practices + +* make dependencies `optional` whenever possible! +* interface types should be used whenever possible to avoid tight couplings between two modules. +* `OnePerModuleType`s should be used when there is something occurs at most once per module and the module name is a +convenient way for providing a deterministic order. +* `ManyPerContainerType`s should be used only when there is an obvious way to create an ordering from the types or +when ordering *really* doesn't matter (which is rare). +* module-scoped providers should be used for private, module-scoped dependencies +* use different providers for unrelated or loosely components or to resolve circular dependencies (see below) +* use invokers sparingly and always `nil`-check the inputs. + +### Resolving Circular Dependencies + +Circular dependencies are inevitable to crop up and there are ways to avoid them. While `depinject` cannot handle +circular dependency graphs of providers, many of the above tools are designed to enable satisfying circular dependencies +between modules. + +One of the key tactics for resolving circular dependencies is to use different providers and/or invokers to allow a +circular dependency between components. For example, say the slashing keeper depends on the keeper module but the +staking keeper also depends on the staking module indirectly (in the form of "staking hooks"). The slashing module +can declare a dependency directly on the staking keeper (using an interface to avoid actually importing the staking +keeper package). It can also provide an instance of the slashing keeper wrapped as staking hooks in a `OnePerModuleType` +we'll call `StakingHooksWrapper`. Now, if the staking module directly depended on the staking hooks wrappers +(`map[string]StakingHooksWrapper`) we would have a circular dependency graph and `depinject` would fail. To fix this, +the staking module can define an invoker which depends on `map[string]StakingHooksWrapper` and the staking keeper +(which was provided by the staking module already in a separate provided). In this way `depinject` will be able to +satisfy this dependency graph which allows staking and slashing to depend on each other in this order: + +* provide staking keeper -> slashing keeper +* provide slashing keeper wrapped as `StakingHooksWrapper` +* get `map[string]StakingHooksWrapper` and the staking keeper and wire them together + +## 3. Testing and Debugging The Module + +In order to test and debug the module configuration, we need to build an app config, generally defined in a YAML file. +This configuration should be passed first to `appconfig.LoadYAML` to get an `depinject.Config` instance.Then the +`depinject.Config` can be passed to `depinject.Inject` and we can try to resolve dependencies in the app config. +Alternatively, the `depinject.Config` can be created via [pure Go code](https://github.com/cosmos/cosmos-sdk/blob/61dc023/simapp/app_config.go). + +Ex: + +```go +//go:embed app.yaml +var appConfig []byte + +var AppConfig = appconfig.LoadYAML(appConfig) + +func TestModule(t *testing.T) { + var keeper Keeper + assert.NilError(t, depinject.Inject(AppConfig, &keeper)) +} +``` + +### Debugging `depinject` Graphs + +Whenever there is an error in a `depinject` graph, by default `depinject` will dump a bunch of logging output to the +console, print the error message, and save the dependency graph in [GraphViz](https://graphviz.org) DOT format to +the file `debug_container.dot`. Inspecting the GraphViz output by converting it to an SVG and viewing it in a web +browser or using some other GraphViz tool is *highly recommended*. + +If `depinject` does not return an error but there is still some weird issue wiring up modules, inspecting the GraphViz +and logging output is still *highly recommended* and can be done using `depinject.InjectDebug` with the debug option +`depinject.Debug`. + +App developers should attempt to familiarize themselves with the GraphViz graph of their app to see which modules +depend on which other modules. From 5ef43f4919d59715df096145439a1022bfe54327 Mon Sep 17 00:00:00 2001 From: atheeshp <59333759+atheeshp@users.noreply.github.com> Date: Fri, 8 Jul 2022 19:17:34 +0530 Subject: [PATCH 13/37] feat: deprecate x/params usage in x/distr (#12434) --- CHANGELOG.md | 2 + api/cosmos/app/v1alpha1/config.pulsar.go | 2 +- .../distribution/v1beta1/genesis.pulsar.go | 2 +- api/cosmos/distribution/v1beta1/tx.pulsar.go | 1128 ++++++++++++++++- api/cosmos/distribution/v1beta1/tx_grpc.pb.go | 44 + .../cosmos/distribution/v1beta1/genesis.proto | 2 +- proto/cosmos/distribution/v1beta1/tx.proto | 28 + x/distribution/exported/exported.go | 18 + x/distribution/keeper/genesis.go | 5 +- x/distribution/keeper/grpc_query.go | 3 +- x/distribution/keeper/grpc_query_test.go | 6 +- x/distribution/keeper/keeper.go | 21 +- x/distribution/keeper/keeper_test.go | 4 +- x/distribution/keeper/migrations.go | 17 +- x/distribution/keeper/msg_server.go | 27 +- x/distribution/keeper/msg_server_test.go | 147 +++ x/distribution/keeper/params.go | 39 +- x/distribution/keeper/params_test.go | 117 ++ x/distribution/keeper/querier_test.go | 2 +- x/distribution/migrations/v046/migrate.go | 40 + .../migrations/v046/migrate_test.go | 44 + x/distribution/module.go | 53 +- x/distribution/spec/02_state.md | 9 + x/distribution/spec/04_messages.md | 10 + x/distribution/types/codec.go | 4 + x/distribution/types/genesis.pb.go | 2 +- x/distribution/types/keys.go | 4 + x/distribution/types/msg.go | 28 +- x/distribution/types/params.go | 24 - x/distribution/types/params_legacy.go | 26 + x/distribution/types/tx.pb.go | 527 +++++++- 31 files changed, 2201 insertions(+), 184 deletions(-) create mode 100644 x/distribution/exported/exported.go create mode 100644 x/distribution/keeper/msg_server_test.go create mode 100644 x/distribution/keeper/params_test.go create mode 100644 x/distribution/migrations/v046/migrate.go create mode 100644 x/distribution/migrations/v046/migrate_test.go create mode 100644 x/distribution/types/params_legacy.go diff --git a/CHANGELOG.md b/CHANGELOG.md index d7f7c5e1e483..3b561e6c9027 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -58,6 +58,7 @@ Ref: https://keepachangelog.com/en/1.0.0/ * (x/slashing) [#12399](https://github.com/cosmos/cosmos-sdk/pull/12399) Migrate `x/slashing` to self-managed parameters and deprecate its usage of `x/params`. * (x/mint) [#12363](https://github.com/cosmos/cosmos-sdk/pull/12363) Migrate `x/mint` to self-managed parameters and deprecate it's usage of `x/params`. +* (x/distribution) [#12434](https://github.com/cosmos/cosmos-sdk/pull/12434) Migrate `x/distribution` to self-managed parameters and deprecate it's usage of `x/params`. ### API Breaking Changes @@ -70,6 +71,7 @@ Ref: https://keepachangelog.com/en/1.0.0/ * (testutil) [#12233](https://github.com/cosmos/cosmos-sdk/pull/12233) Move `simapp.TestAddr` to `simtestutil.TestAddr` (`testutil/sims`) * (x/staking) [#12102](https://github.com/cosmos/cosmos-sdk/pull/12102) Staking keeper now is passed by reference instead of copy. Keeper's SetHooks no longer returns keeper. It updates the keeper in place instead. * (linting) [#12141](https://github.com/cosmos/cosmos-sdk/pull/12141) Fix usability related linting for database. This means removing the infix Prefix from `prefix.NewPrefixWriter` and such so that it is `prefix.NewWriter` and making `db.DBConnection` and such into `db.Connection` +* (x/distribution) [#12434](https://github.com/cosmos/cosmos-sdk/pull/12434) `x/distribution` module `SetParams` keeper method definition is now updated to return `error`. ### Bug Fixes diff --git a/api/cosmos/app/v1alpha1/config.pulsar.go b/api/cosmos/app/v1alpha1/config.pulsar.go index 7359179ac6ac..34dfc0d7459c 100644 --- a/api/cosmos/app/v1alpha1/config.pulsar.go +++ b/api/cosmos/app/v1alpha1/config.pulsar.go @@ -1850,7 +1850,7 @@ type ModuleConfig struct { // that the v1 module had. Note: modules should provide info on which versions // they can migrate from in the ModuleDescriptor.can_migration_from field. Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - // config is the config object for the module. Module config messages shouldA + // config is the config object for the module. Module config messages should // define a ModuleDescriptor using the cosmos.app.v1alpha1.is_module extension. Config *anypb.Any `protobuf:"bytes,2,opt,name=config,proto3" json:"config,omitempty"` // golang_bindings specifies explicit interface to implementation type bindings which diff --git a/api/cosmos/distribution/v1beta1/genesis.pulsar.go b/api/cosmos/distribution/v1beta1/genesis.pulsar.go index a005a8f1238c..50aedee2a4e3 100644 --- a/api/cosmos/distribution/v1beta1/genesis.pulsar.go +++ b/api/cosmos/distribution/v1beta1/genesis.pulsar.go @@ -5685,7 +5685,7 @@ type GenesisState struct { sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // params defines all the paramaters of the module. + // params defines all the parameters of the module. Params *Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params,omitempty"` // fee_pool defines the fee pool at genesis. FeePool *FeePool `protobuf:"bytes,2,opt,name=fee_pool,json=feePool,proto3" json:"fee_pool,omitempty"` diff --git a/api/cosmos/distribution/v1beta1/tx.pulsar.go b/api/cosmos/distribution/v1beta1/tx.pulsar.go index eebf41d9e62f..7278b963e550 100644 --- a/api/cosmos/distribution/v1beta1/tx.pulsar.go +++ b/api/cosmos/distribution/v1beta1/tx.pulsar.go @@ -3662,6 +3662,861 @@ func (x *fastReflection_MsgFundCommunityPoolResponse) ProtoMethods() *protoiface } } +var ( + md_MsgUpdateParams protoreflect.MessageDescriptor + fd_MsgUpdateParams_authority protoreflect.FieldDescriptor + fd_MsgUpdateParams_params protoreflect.FieldDescriptor +) + +func init() { + file_cosmos_distribution_v1beta1_tx_proto_init() + md_MsgUpdateParams = File_cosmos_distribution_v1beta1_tx_proto.Messages().ByName("MsgUpdateParams") + fd_MsgUpdateParams_authority = md_MsgUpdateParams.Fields().ByName("authority") + fd_MsgUpdateParams_params = md_MsgUpdateParams.Fields().ByName("params") +} + +var _ protoreflect.Message = (*fastReflection_MsgUpdateParams)(nil) + +type fastReflection_MsgUpdateParams MsgUpdateParams + +func (x *MsgUpdateParams) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgUpdateParams)(x) +} + +func (x *MsgUpdateParams) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_distribution_v1beta1_tx_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_MsgUpdateParams_messageType fastReflection_MsgUpdateParams_messageType +var _ protoreflect.MessageType = fastReflection_MsgUpdateParams_messageType{} + +type fastReflection_MsgUpdateParams_messageType struct{} + +func (x fastReflection_MsgUpdateParams_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgUpdateParams)(nil) +} +func (x fastReflection_MsgUpdateParams_messageType) New() protoreflect.Message { + return new(fastReflection_MsgUpdateParams) +} +func (x fastReflection_MsgUpdateParams_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgUpdateParams +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgUpdateParams) Descriptor() protoreflect.MessageDescriptor { + return md_MsgUpdateParams +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_MsgUpdateParams) Type() protoreflect.MessageType { + return _fastReflection_MsgUpdateParams_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgUpdateParams) New() protoreflect.Message { + return new(fastReflection_MsgUpdateParams) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgUpdateParams) Interface() protoreflect.ProtoMessage { + return (*MsgUpdateParams)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_MsgUpdateParams) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Authority != "" { + value := protoreflect.ValueOfString(x.Authority) + if !f(fd_MsgUpdateParams_authority, value) { + return + } + } + if x.Params != nil { + value := protoreflect.ValueOfMessage(x.Params.ProtoReflect()) + if !f(fd_MsgUpdateParams_params, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_MsgUpdateParams) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "cosmos.distribution.v1beta1.MsgUpdateParams.authority": + return x.Authority != "" + case "cosmos.distribution.v1beta1.MsgUpdateParams.params": + return x.Params != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.distribution.v1beta1.MsgUpdateParams")) + } + panic(fmt.Errorf("message cosmos.distribution.v1beta1.MsgUpdateParams does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_MsgUpdateParams) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "cosmos.distribution.v1beta1.MsgUpdateParams.authority": + x.Authority = "" + case "cosmos.distribution.v1beta1.MsgUpdateParams.params": + x.Params = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.distribution.v1beta1.MsgUpdateParams")) + } + panic(fmt.Errorf("message cosmos.distribution.v1beta1.MsgUpdateParams does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_MsgUpdateParams) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "cosmos.distribution.v1beta1.MsgUpdateParams.authority": + value := x.Authority + return protoreflect.ValueOfString(value) + case "cosmos.distribution.v1beta1.MsgUpdateParams.params": + value := x.Params + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.distribution.v1beta1.MsgUpdateParams")) + } + panic(fmt.Errorf("message cosmos.distribution.v1beta1.MsgUpdateParams does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_MsgUpdateParams) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "cosmos.distribution.v1beta1.MsgUpdateParams.authority": + x.Authority = value.Interface().(string) + case "cosmos.distribution.v1beta1.MsgUpdateParams.params": + x.Params = value.Message().Interface().(*Params) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.distribution.v1beta1.MsgUpdateParams")) + } + panic(fmt.Errorf("message cosmos.distribution.v1beta1.MsgUpdateParams does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_MsgUpdateParams) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.distribution.v1beta1.MsgUpdateParams.params": + if x.Params == nil { + x.Params = new(Params) + } + return protoreflect.ValueOfMessage(x.Params.ProtoReflect()) + case "cosmos.distribution.v1beta1.MsgUpdateParams.authority": + panic(fmt.Errorf("field authority of message cosmos.distribution.v1beta1.MsgUpdateParams is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.distribution.v1beta1.MsgUpdateParams")) + } + panic(fmt.Errorf("message cosmos.distribution.v1beta1.MsgUpdateParams does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_MsgUpdateParams) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.distribution.v1beta1.MsgUpdateParams.authority": + return protoreflect.ValueOfString("") + case "cosmos.distribution.v1beta1.MsgUpdateParams.params": + m := new(Params) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.distribution.v1beta1.MsgUpdateParams")) + } + panic(fmt.Errorf("message cosmos.distribution.v1beta1.MsgUpdateParams does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_MsgUpdateParams) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.distribution.v1beta1.MsgUpdateParams", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_MsgUpdateParams) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_MsgUpdateParams) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_MsgUpdateParams) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_MsgUpdateParams) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgUpdateParams) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + l = len(x.Authority) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.Params != nil { + l = options.Size(x.Params) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*MsgUpdateParams) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if x.Params != nil { + encoded, err := options.Marshal(x.Params) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x12 + } + if len(x.Authority) > 0 { + i -= len(x.Authority) + copy(dAtA[i:], x.Authority) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Authority))) + i-- + dAtA[i] = 0xa + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*MsgUpdateParams) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUpdateParams: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUpdateParams: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Authority = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Params", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.Params == nil { + x.Params = &Params{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Params); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_MsgUpdateParamsResponse protoreflect.MessageDescriptor +) + +func init() { + file_cosmos_distribution_v1beta1_tx_proto_init() + md_MsgUpdateParamsResponse = File_cosmos_distribution_v1beta1_tx_proto.Messages().ByName("MsgUpdateParamsResponse") +} + +var _ protoreflect.Message = (*fastReflection_MsgUpdateParamsResponse)(nil) + +type fastReflection_MsgUpdateParamsResponse MsgUpdateParamsResponse + +func (x *MsgUpdateParamsResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgUpdateParamsResponse)(x) +} + +func (x *MsgUpdateParamsResponse) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_distribution_v1beta1_tx_proto_msgTypes[9] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_MsgUpdateParamsResponse_messageType fastReflection_MsgUpdateParamsResponse_messageType +var _ protoreflect.MessageType = fastReflection_MsgUpdateParamsResponse_messageType{} + +type fastReflection_MsgUpdateParamsResponse_messageType struct{} + +func (x fastReflection_MsgUpdateParamsResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgUpdateParamsResponse)(nil) +} +func (x fastReflection_MsgUpdateParamsResponse_messageType) New() protoreflect.Message { + return new(fastReflection_MsgUpdateParamsResponse) +} +func (x fastReflection_MsgUpdateParamsResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgUpdateParamsResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgUpdateParamsResponse) Descriptor() protoreflect.MessageDescriptor { + return md_MsgUpdateParamsResponse +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_MsgUpdateParamsResponse) Type() protoreflect.MessageType { + return _fastReflection_MsgUpdateParamsResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgUpdateParamsResponse) New() protoreflect.Message { + return new(fastReflection_MsgUpdateParamsResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgUpdateParamsResponse) Interface() protoreflect.ProtoMessage { + return (*MsgUpdateParamsResponse)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_MsgUpdateParamsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_MsgUpdateParamsResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.distribution.v1beta1.MsgUpdateParamsResponse")) + } + panic(fmt.Errorf("message cosmos.distribution.v1beta1.MsgUpdateParamsResponse does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_MsgUpdateParamsResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.distribution.v1beta1.MsgUpdateParamsResponse")) + } + panic(fmt.Errorf("message cosmos.distribution.v1beta1.MsgUpdateParamsResponse does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_MsgUpdateParamsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.distribution.v1beta1.MsgUpdateParamsResponse")) + } + panic(fmt.Errorf("message cosmos.distribution.v1beta1.MsgUpdateParamsResponse does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_MsgUpdateParamsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.distribution.v1beta1.MsgUpdateParamsResponse")) + } + panic(fmt.Errorf("message cosmos.distribution.v1beta1.MsgUpdateParamsResponse does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_MsgUpdateParamsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.distribution.v1beta1.MsgUpdateParamsResponse")) + } + panic(fmt.Errorf("message cosmos.distribution.v1beta1.MsgUpdateParamsResponse does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_MsgUpdateParamsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.distribution.v1beta1.MsgUpdateParamsResponse")) + } + panic(fmt.Errorf("message cosmos.distribution.v1beta1.MsgUpdateParamsResponse does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_MsgUpdateParamsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.distribution.v1beta1.MsgUpdateParamsResponse", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_MsgUpdateParamsResponse) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_MsgUpdateParamsResponse) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_MsgUpdateParamsResponse) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_MsgUpdateParamsResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgUpdateParamsResponse) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*MsgUpdateParamsResponse) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*MsgUpdateParamsResponse) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUpdateParamsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUpdateParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.27.0 @@ -3975,6 +4830,86 @@ func (*MsgFundCommunityPoolResponse) Descriptor() ([]byte, []int) { return file_cosmos_distribution_v1beta1_tx_proto_rawDescGZIP(), []int{7} } +// MsgUpdateParams is the Msg/UpdateParams request type. +// +// Since: cosmos-sdk 0.47 +type MsgUpdateParams struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // authority is the address of the governance account. + Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"` + // params defines the x/distribution parameters to update. + // + // NOTE: All parameters must be supplied. + Params *Params `protobuf:"bytes,2,opt,name=params,proto3" json:"params,omitempty"` +} + +func (x *MsgUpdateParams) Reset() { + *x = MsgUpdateParams{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_distribution_v1beta1_tx_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgUpdateParams) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgUpdateParams) ProtoMessage() {} + +// Deprecated: Use MsgUpdateParams.ProtoReflect.Descriptor instead. +func (*MsgUpdateParams) Descriptor() ([]byte, []int) { + return file_cosmos_distribution_v1beta1_tx_proto_rawDescGZIP(), []int{8} +} + +func (x *MsgUpdateParams) GetAuthority() string { + if x != nil { + return x.Authority + } + return "" +} + +func (x *MsgUpdateParams) GetParams() *Params { + if x != nil { + return x.Params + } + return nil +} + +// MsgUpdateParamsResponse defines the response structure for executing a +// MsgUpdateParams message. +// +// Since: cosmos-sdk 0.47 +type MsgUpdateParamsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *MsgUpdateParamsResponse) Reset() { + *x = MsgUpdateParamsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_distribution_v1beta1_tx_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgUpdateParamsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgUpdateParamsResponse) ProtoMessage() {} + +// Deprecated: Use MsgUpdateParamsResponse.ProtoReflect.Descriptor instead. +func (*MsgUpdateParamsResponse) Descriptor() ([]byte, []int) { + return file_cosmos_distribution_v1beta1_tx_proto_rawDescGZIP(), []int{9} +} + var File_cosmos_distribution_v1beta1_tx_proto protoreflect.FileDescriptor var file_cosmos_distribution_v1beta1_tx_proto_rawDesc = []byte{ @@ -3988,7 +4923,10 @@ var file_cosmos_distribution_v1beta1_tx_proto_rawDesc = []byte{ 0x6f, 0x69, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x19, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x17, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x6d, 0x73, 0x67, - 0x2f, 0x76, 0x31, 0x2f, 0x6d, 0x73, 0x67, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xc3, 0x01, + 0x2f, 0x76, 0x31, 0x2f, 0x6d, 0x73, 0x67, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x2e, 0x63, + 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, + 0x6f, 0x6e, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x64, 0x69, 0x73, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xc3, 0x01, 0x0a, 0x15, 0x4d, 0x73, 0x67, 0x53, 0x65, 0x74, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x45, 0x0a, 0x11, 0x64, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, @@ -4057,60 +4995,79 @@ var file_cosmos_distribution_v1beta1_tx_proto_rawDesc = []byte{ 0xa0, 0x1f, 0x00, 0xe8, 0xa0, 0x1f, 0x00, 0x82, 0xe7, 0xb0, 0x2a, 0x09, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x22, 0x1e, 0x0a, 0x1c, 0x4d, 0x73, 0x67, 0x46, 0x75, 0x6e, 0x64, 0x43, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x6f, 0x6c, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x32, 0xc8, 0x04, 0x0a, 0x03, 0x4d, 0x73, 0x67, 0x12, 0x84, 0x01, - 0x0a, 0x12, 0x53, 0x65, 0x74, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x41, 0x64, 0x64, - 0x72, 0x65, 0x73, 0x73, 0x12, 0x32, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x64, 0x69, - 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, - 0x61, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x65, 0x74, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, - 0x77, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x1a, 0x3a, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, - 0x73, 0x2e, 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x76, - 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x65, 0x74, 0x57, 0x69, 0x74, - 0x68, 0x64, 0x72, 0x61, 0x77, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x93, 0x01, 0x0a, 0x17, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, - 0x77, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, - 0x12, 0x37, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, - 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4d, - 0x73, 0x67, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, - 0x74, 0x6f, 0x72, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x1a, 0x3f, 0x2e, 0x63, 0x6f, 0x73, 0x6d, - 0x6f, 0x73, 0x2e, 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, - 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x57, 0x69, 0x74, 0x68, 0x64, - 0x72, 0x61, 0x77, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x77, 0x61, - 0x72, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x9f, 0x01, 0x0a, 0x1b, 0x57, - 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, - 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x3b, 0x2e, 0x63, 0x6f, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x9c, 0x01, 0x0a, 0x0f, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, + 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x36, 0x0a, 0x09, 0x61, 0x75, 0x74, + 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, + 0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, + 0x79, 0x12, 0x41, 0x0a, 0x06, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x23, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x64, 0x69, 0x73, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, + 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x06, 0x70, 0x61, + 0x72, 0x61, 0x6d, 0x73, 0x3a, 0x0e, 0x82, 0xe7, 0xb0, 0x2a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, + 0x72, 0x69, 0x74, 0x79, 0x22, 0x19, 0x0a, 0x17, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, + 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x32, + 0xbc, 0x05, 0x0a, 0x03, 0x4d, 0x73, 0x67, 0x12, 0x84, 0x01, 0x0a, 0x12, 0x53, 0x65, 0x74, 0x57, + 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x32, + 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, + 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4d, 0x73, 0x67, + 0x53, 0x65, 0x74, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x41, 0x64, 0x64, 0x72, 0x65, + 0x73, 0x73, 0x1a, 0x3a, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x64, 0x69, 0x73, 0x74, + 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, + 0x2e, 0x4d, 0x73, 0x67, 0x53, 0x65, 0x74, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x41, + 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x93, + 0x01, 0x0a, 0x17, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x44, 0x65, 0x6c, 0x65, 0x67, + 0x61, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x12, 0x37, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x57, 0x69, 0x74, 0x68, - 0x64, 0x72, 0x61, 0x77, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x43, 0x6f, 0x6d, - 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x1a, 0x43, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, - 0x2e, 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x76, 0x31, - 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, + 0x64, 0x72, 0x61, 0x77, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x77, + 0x61, 0x72, 0x64, 0x1a, 0x3f, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x64, 0x69, 0x73, + 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, + 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x44, 0x65, 0x6c, + 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x9f, 0x01, 0x0a, 0x1b, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x73, - 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x81, 0x01, 0x0a, - 0x11, 0x46, 0x75, 0x6e, 0x64, 0x43, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x74, 0x79, 0x50, 0x6f, - 0x6f, 0x6c, 0x12, 0x31, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x64, 0x69, 0x73, 0x74, - 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, - 0x2e, 0x4d, 0x73, 0x67, 0x46, 0x75, 0x6e, 0x64, 0x43, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x74, - 0x79, 0x50, 0x6f, 0x6f, 0x6c, 0x1a, 0x39, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x64, - 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x76, 0x31, 0x62, 0x65, - 0x74, 0x61, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x46, 0x75, 0x6e, 0x64, 0x43, 0x6f, 0x6d, 0x6d, 0x75, - 0x6e, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x6f, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x42, 0xfe, 0x01, 0x0a, 0x1f, 0x63, 0x6f, 0x6d, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, - 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x76, 0x31, 0x62, - 0x65, 0x74, 0x61, 0x31, 0x42, 0x07, 0x54, 0x78, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, - 0x40, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x61, 0x70, - 0x69, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, - 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x3b, 0x64, 0x69, - 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, - 0x31, 0xa2, 0x02, 0x03, 0x43, 0x44, 0x58, 0xaa, 0x02, 0x1b, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, - 0x2e, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x56, 0x31, - 0x62, 0x65, 0x74, 0x61, 0x31, 0xca, 0x02, 0x1b, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x44, - 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5c, 0x56, 0x31, 0x62, 0x65, - 0x74, 0x61, 0x31, 0xe2, 0x02, 0x27, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x44, 0x69, 0x73, + 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x3b, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x64, 0x69, + 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, + 0x61, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x56, 0x61, + 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, + 0x6e, 0x1a, 0x43, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x64, 0x69, 0x73, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, + 0x4d, 0x73, 0x67, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x56, 0x61, 0x6c, 0x69, 0x64, + 0x61, 0x74, 0x6f, 0x72, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x81, 0x01, 0x0a, 0x11, 0x46, 0x75, 0x6e, 0x64, 0x43, + 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x6f, 0x6c, 0x12, 0x31, 0x2e, 0x63, + 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, + 0x6f, 0x6e, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x46, 0x75, + 0x6e, 0x64, 0x43, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x6f, 0x6c, 0x1a, + 0x39, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, + 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4d, 0x73, + 0x67, 0x46, 0x75, 0x6e, 0x64, 0x43, 0x6f, 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x74, 0x79, 0x50, 0x6f, + 0x6f, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x72, 0x0a, 0x0c, 0x55, 0x70, + 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x2c, 0x2e, 0x63, 0x6f, 0x73, + 0x6d, 0x6f, 0x73, 0x2e, 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, + 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, + 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x1a, 0x34, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, + 0x73, 0x2e, 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x76, + 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, + 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0xfe, + 0x01, 0x0a, 0x1f, 0x63, 0x6f, 0x6d, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x64, 0x69, + 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, + 0x61, 0x31, 0x42, 0x07, 0x54, 0x78, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x40, 0x63, + 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, + 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, + 0x69, 0x6f, 0x6e, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x3b, 0x64, 0x69, 0x73, 0x74, + 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0xa2, + 0x02, 0x03, 0x43, 0x44, 0x58, 0xaa, 0x02, 0x1b, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x44, + 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x56, 0x31, 0x62, 0x65, + 0x74, 0x61, 0x31, 0xca, 0x02, 0x1b, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5c, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, - 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x1d, - 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x3a, 0x3a, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, - 0x74, 0x69, 0x6f, 0x6e, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0xa8, 0xe2, 0x1e, - 0x01, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x31, 0xe2, 0x02, 0x27, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x44, 0x69, 0x73, 0x74, 0x72, + 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5c, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x5c, + 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x1d, 0x43, 0x6f, + 0x73, 0x6d, 0x6f, 0x73, 0x3a, 0x3a, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, + 0x6f, 0x6e, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0xa8, 0xe2, 0x1e, 0x01, 0x62, + 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var ( @@ -4125,7 +5082,7 @@ func file_cosmos_distribution_v1beta1_tx_proto_rawDescGZIP() []byte { return file_cosmos_distribution_v1beta1_tx_proto_rawDescData } -var file_cosmos_distribution_v1beta1_tx_proto_msgTypes = make([]protoimpl.MessageInfo, 8) +var file_cosmos_distribution_v1beta1_tx_proto_msgTypes = make([]protoimpl.MessageInfo, 10) var file_cosmos_distribution_v1beta1_tx_proto_goTypes = []interface{}{ (*MsgSetWithdrawAddress)(nil), // 0: cosmos.distribution.v1beta1.MsgSetWithdrawAddress (*MsgSetWithdrawAddressResponse)(nil), // 1: cosmos.distribution.v1beta1.MsgSetWithdrawAddressResponse @@ -4135,25 +5092,31 @@ var file_cosmos_distribution_v1beta1_tx_proto_goTypes = []interface{}{ (*MsgWithdrawValidatorCommissionResponse)(nil), // 5: cosmos.distribution.v1beta1.MsgWithdrawValidatorCommissionResponse (*MsgFundCommunityPool)(nil), // 6: cosmos.distribution.v1beta1.MsgFundCommunityPool (*MsgFundCommunityPoolResponse)(nil), // 7: cosmos.distribution.v1beta1.MsgFundCommunityPoolResponse - (*v1beta1.Coin)(nil), // 8: cosmos.base.v1beta1.Coin + (*MsgUpdateParams)(nil), // 8: cosmos.distribution.v1beta1.MsgUpdateParams + (*MsgUpdateParamsResponse)(nil), // 9: cosmos.distribution.v1beta1.MsgUpdateParamsResponse + (*v1beta1.Coin)(nil), // 10: cosmos.base.v1beta1.Coin + (*Params)(nil), // 11: cosmos.distribution.v1beta1.Params } var file_cosmos_distribution_v1beta1_tx_proto_depIdxs = []int32{ - 8, // 0: cosmos.distribution.v1beta1.MsgWithdrawDelegatorRewardResponse.amount:type_name -> cosmos.base.v1beta1.Coin - 8, // 1: cosmos.distribution.v1beta1.MsgWithdrawValidatorCommissionResponse.amount:type_name -> cosmos.base.v1beta1.Coin - 8, // 2: cosmos.distribution.v1beta1.MsgFundCommunityPool.amount:type_name -> cosmos.base.v1beta1.Coin - 0, // 3: cosmos.distribution.v1beta1.Msg.SetWithdrawAddress:input_type -> cosmos.distribution.v1beta1.MsgSetWithdrawAddress - 2, // 4: cosmos.distribution.v1beta1.Msg.WithdrawDelegatorReward:input_type -> cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward - 4, // 5: cosmos.distribution.v1beta1.Msg.WithdrawValidatorCommission:input_type -> cosmos.distribution.v1beta1.MsgWithdrawValidatorCommission - 6, // 6: cosmos.distribution.v1beta1.Msg.FundCommunityPool:input_type -> cosmos.distribution.v1beta1.MsgFundCommunityPool - 1, // 7: cosmos.distribution.v1beta1.Msg.SetWithdrawAddress:output_type -> cosmos.distribution.v1beta1.MsgSetWithdrawAddressResponse - 3, // 8: cosmos.distribution.v1beta1.Msg.WithdrawDelegatorReward:output_type -> cosmos.distribution.v1beta1.MsgWithdrawDelegatorRewardResponse - 5, // 9: cosmos.distribution.v1beta1.Msg.WithdrawValidatorCommission:output_type -> cosmos.distribution.v1beta1.MsgWithdrawValidatorCommissionResponse - 7, // 10: cosmos.distribution.v1beta1.Msg.FundCommunityPool:output_type -> cosmos.distribution.v1beta1.MsgFundCommunityPoolResponse - 7, // [7:11] is the sub-list for method output_type - 3, // [3:7] is the sub-list for method input_type - 3, // [3:3] is the sub-list for extension type_name - 3, // [3:3] is the sub-list for extension extendee - 0, // [0:3] is the sub-list for field type_name + 10, // 0: cosmos.distribution.v1beta1.MsgWithdrawDelegatorRewardResponse.amount:type_name -> cosmos.base.v1beta1.Coin + 10, // 1: cosmos.distribution.v1beta1.MsgWithdrawValidatorCommissionResponse.amount:type_name -> cosmos.base.v1beta1.Coin + 10, // 2: cosmos.distribution.v1beta1.MsgFundCommunityPool.amount:type_name -> cosmos.base.v1beta1.Coin + 11, // 3: cosmos.distribution.v1beta1.MsgUpdateParams.params:type_name -> cosmos.distribution.v1beta1.Params + 0, // 4: cosmos.distribution.v1beta1.Msg.SetWithdrawAddress:input_type -> cosmos.distribution.v1beta1.MsgSetWithdrawAddress + 2, // 5: cosmos.distribution.v1beta1.Msg.WithdrawDelegatorReward:input_type -> cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward + 4, // 6: cosmos.distribution.v1beta1.Msg.WithdrawValidatorCommission:input_type -> cosmos.distribution.v1beta1.MsgWithdrawValidatorCommission + 6, // 7: cosmos.distribution.v1beta1.Msg.FundCommunityPool:input_type -> cosmos.distribution.v1beta1.MsgFundCommunityPool + 8, // 8: cosmos.distribution.v1beta1.Msg.UpdateParams:input_type -> cosmos.distribution.v1beta1.MsgUpdateParams + 1, // 9: cosmos.distribution.v1beta1.Msg.SetWithdrawAddress:output_type -> cosmos.distribution.v1beta1.MsgSetWithdrawAddressResponse + 3, // 10: cosmos.distribution.v1beta1.Msg.WithdrawDelegatorReward:output_type -> cosmos.distribution.v1beta1.MsgWithdrawDelegatorRewardResponse + 5, // 11: cosmos.distribution.v1beta1.Msg.WithdrawValidatorCommission:output_type -> cosmos.distribution.v1beta1.MsgWithdrawValidatorCommissionResponse + 7, // 12: cosmos.distribution.v1beta1.Msg.FundCommunityPool:output_type -> cosmos.distribution.v1beta1.MsgFundCommunityPoolResponse + 9, // 13: cosmos.distribution.v1beta1.Msg.UpdateParams:output_type -> cosmos.distribution.v1beta1.MsgUpdateParamsResponse + 9, // [9:14] is the sub-list for method output_type + 4, // [4:9] is the sub-list for method input_type + 4, // [4:4] is the sub-list for extension type_name + 4, // [4:4] is the sub-list for extension extendee + 0, // [0:4] is the sub-list for field type_name } func init() { file_cosmos_distribution_v1beta1_tx_proto_init() } @@ -4161,6 +5124,7 @@ func file_cosmos_distribution_v1beta1_tx_proto_init() { if File_cosmos_distribution_v1beta1_tx_proto != nil { return } + file_cosmos_distribution_v1beta1_distribution_proto_init() if !protoimpl.UnsafeEnabled { file_cosmos_distribution_v1beta1_tx_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*MsgSetWithdrawAddress); i { @@ -4258,6 +5222,30 @@ func file_cosmos_distribution_v1beta1_tx_proto_init() { return nil } } + file_cosmos_distribution_v1beta1_tx_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgUpdateParams); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cosmos_distribution_v1beta1_tx_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgUpdateParamsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } } type x struct{} out := protoimpl.TypeBuilder{ @@ -4265,7 +5253,7 @@ func file_cosmos_distribution_v1beta1_tx_proto_init() { GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: file_cosmos_distribution_v1beta1_tx_proto_rawDesc, NumEnums: 0, - NumMessages: 8, + NumMessages: 10, NumExtensions: 0, NumServices: 1, }, diff --git a/api/cosmos/distribution/v1beta1/tx_grpc.pb.go b/api/cosmos/distribution/v1beta1/tx_grpc.pb.go index 22dce9ef26e9..d94242df65bc 100644 --- a/api/cosmos/distribution/v1beta1/tx_grpc.pb.go +++ b/api/cosmos/distribution/v1beta1/tx_grpc.pb.go @@ -34,6 +34,11 @@ type MsgClient interface { // FundCommunityPool defines a method to allow an account to directly // fund the community pool. FundCommunityPool(ctx context.Context, in *MsgFundCommunityPool, opts ...grpc.CallOption) (*MsgFundCommunityPoolResponse, error) + // UpdateParams defines a governance operation for updating the x/distribution module + // parameters. The authority is defined in the keeper. + // + // Since: cosmos-sdk 0.47 + UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) } type msgClient struct { @@ -80,6 +85,15 @@ func (c *msgClient) FundCommunityPool(ctx context.Context, in *MsgFundCommunityP return out, nil } +func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) { + out := new(MsgUpdateParamsResponse) + err := c.cc.Invoke(ctx, "/cosmos.distribution.v1beta1.Msg/UpdateParams", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // MsgServer is the server API for Msg service. // All implementations must embed UnimplementedMsgServer // for forward compatibility @@ -96,6 +110,11 @@ type MsgServer interface { // FundCommunityPool defines a method to allow an account to directly // fund the community pool. FundCommunityPool(context.Context, *MsgFundCommunityPool) (*MsgFundCommunityPoolResponse, error) + // UpdateParams defines a governance operation for updating the x/distribution module + // parameters. The authority is defined in the keeper. + // + // Since: cosmos-sdk 0.47 + UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error) mustEmbedUnimplementedMsgServer() } @@ -115,6 +134,9 @@ func (UnimplementedMsgServer) WithdrawValidatorCommission(context.Context, *MsgW func (UnimplementedMsgServer) FundCommunityPool(context.Context, *MsgFundCommunityPool) (*MsgFundCommunityPoolResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method FundCommunityPool not implemented") } +func (UnimplementedMsgServer) UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateParams not implemented") +} func (UnimplementedMsgServer) mustEmbedUnimplementedMsgServer() {} // UnsafeMsgServer may be embedded to opt out of forward compatibility for this service. @@ -200,6 +222,24 @@ func _Msg_FundCommunityPool_Handler(srv interface{}, ctx context.Context, dec fu return interceptor(ctx, in, info, handler) } +func _Msg_UpdateParams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgUpdateParams) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).UpdateParams(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmos.distribution.v1beta1.Msg/UpdateParams", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).UpdateParams(ctx, req.(*MsgUpdateParams)) + } + return interceptor(ctx, in, info, handler) +} + // Msg_ServiceDesc is the grpc.ServiceDesc for Msg service. // It's only intended for direct use with grpc.RegisterService, // and not to be introspected or modified (even as a copy) @@ -223,6 +263,10 @@ var Msg_ServiceDesc = grpc.ServiceDesc{ MethodName: "FundCommunityPool", Handler: _Msg_FundCommunityPool_Handler, }, + { + MethodName: "UpdateParams", + Handler: _Msg_UpdateParams_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "cosmos/distribution/v1beta1/tx.proto", diff --git a/proto/cosmos/distribution/v1beta1/genesis.proto b/proto/cosmos/distribution/v1beta1/genesis.proto index 4662e8df42be..239ba42f61b0 100644 --- a/proto/cosmos/distribution/v1beta1/genesis.proto +++ b/proto/cosmos/distribution/v1beta1/genesis.proto @@ -112,7 +112,7 @@ message GenesisState { option (gogoproto.equal) = false; option (gogoproto.goproto_getters) = false; - // params defines all the paramaters of the module. + // params defines all the parameters of the module. Params params = 1 [(gogoproto.nullable) = false]; // fee_pool defines the fee pool at genesis. diff --git a/proto/cosmos/distribution/v1beta1/tx.proto b/proto/cosmos/distribution/v1beta1/tx.proto index 68fea0c27c16..25f6433d2f56 100644 --- a/proto/cosmos/distribution/v1beta1/tx.proto +++ b/proto/cosmos/distribution/v1beta1/tx.proto @@ -8,6 +8,7 @@ import "gogoproto/gogo.proto"; import "cosmos/base/v1beta1/coin.proto"; import "cosmos_proto/cosmos.proto"; import "cosmos/msg/v1/msg.proto"; +import "cosmos/distribution/v1beta1/distribution.proto"; // Msg defines the distribution Msg service. service Msg { @@ -26,6 +27,12 @@ service Msg { // FundCommunityPool defines a method to allow an account to directly // fund the community pool. rpc FundCommunityPool(MsgFundCommunityPool) returns (MsgFundCommunityPoolResponse); + + // UpdateParams defines a governance operation for updating the x/distribution module + // parameters. The authority is defined in the keeper. + // + // Since: cosmos-sdk 0.47 + rpc UpdateParams(MsgUpdateParams) returns (MsgUpdateParamsResponse); } // MsgSetWithdrawAddress sets the withdraw address for @@ -95,3 +102,24 @@ message MsgFundCommunityPool { // MsgFundCommunityPoolResponse defines the Msg/FundCommunityPool response type. message MsgFundCommunityPoolResponse {} + +// MsgUpdateParams is the Msg/UpdateParams request type. +// +// Since: cosmos-sdk 0.47 +message MsgUpdateParams { + option (cosmos.msg.v1.signer) = "authority"; + + // authority is the address of the governance account. + string authority = 1 [(cosmos_proto.scalar) = "cosmos.AddressString"]; + + // params defines the x/distribution parameters to update. + // + // NOTE: All parameters must be supplied. + Params params = 2 [(gogoproto.nullable) = false]; +} + +// MsgUpdateParamsResponse defines the response structure for executing a +// MsgUpdateParams message. +// +// Since: cosmos-sdk 0.47 +message MsgUpdateParamsResponse {} diff --git a/x/distribution/exported/exported.go b/x/distribution/exported/exported.go new file mode 100644 index 000000000000..000114e6194d --- /dev/null +++ b/x/distribution/exported/exported.go @@ -0,0 +1,18 @@ +package exported + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" +) + +type ( + ParamSet = paramtypes.ParamSet + + // Subspace defines an interface that implements the legacy x/params Subspace + // type. + // + // NOTE: This is used solely for migration of x/params managed parameters. + Subspace interface { + GetParamSet(ctx sdk.Context, ps ParamSet) + } +) diff --git a/x/distribution/keeper/genesis.go b/x/distribution/keeper/genesis.go index 6236e74902c8..ef80f1fd14db 100644 --- a/x/distribution/keeper/genesis.go +++ b/x/distribution/keeper/genesis.go @@ -12,7 +12,10 @@ func (k Keeper) InitGenesis(ctx sdk.Context, data types.GenesisState) { var moduleHoldings sdk.DecCoins k.SetFeePool(ctx, data.FeePool) - k.SetParams(ctx, data.Params) + + if err := k.SetParams(ctx, data.Params); err != nil { + panic(err) + } for _, dwi := range data.DelegatorWithdrawInfos { delegatorAddress := sdk.MustAccAddressFromBech32(dwi.DelegatorAddress) diff --git a/x/distribution/keeper/grpc_query.go b/x/distribution/keeper/grpc_query.go index bbc884276a06..2daceeafbc08 100644 --- a/x/distribution/keeper/grpc_query.go +++ b/x/distribution/keeper/grpc_query.go @@ -19,8 +19,7 @@ var _ types.QueryServer = Keeper{} // Params queries params of distribution module func (k Keeper) Params(c context.Context, req *types.QueryParamsRequest) (*types.QueryParamsResponse, error) { ctx := sdk.UnwrapSDKContext(c) - var params types.Params - k.paramSpace.GetParamSet(ctx, ¶ms) + params := k.GetParams(ctx) return &types.QueryParamsResponse{Params: params}, nil } diff --git a/x/distribution/keeper/grpc_query_test.go b/x/distribution/keeper/grpc_query_test.go index 03e5e2a3aa86..07ef93ba9acd 100644 --- a/x/distribution/keeper/grpc_query_test.go +++ b/x/distribution/keeper/grpc_query_test.go @@ -36,6 +36,7 @@ type KeeperTestSuite struct { bankKeeper bankkeeper.Keeper distrKeeper keeper.Keeper stakingKeeper *stakingkeeper.Keeper + msgServer types.MsgServer } func (suite *KeeperTestSuite) SetupTest() { @@ -58,6 +59,9 @@ func (suite *KeeperTestSuite) SetupTest() { suite.addrs = simtestutil.AddTestAddrs(suite.bankKeeper, suite.stakingKeeper, ctx, 2, sdk.NewInt(1000000000)) suite.valAddrs = simtestutil.ConvertAddrsToValAddrs(suite.addrs) + + suite.NoError(suite.distrKeeper.SetParams(suite.ctx, types.DefaultParams())) + suite.msgServer = keeper.NewMsgServerImpl(suite.distrKeeper) } func (suite *KeeperTestSuite) TestGRPCParams() { @@ -92,7 +96,7 @@ func (suite *KeeperTestSuite) TestGRPCParams() { WithdrawAddrEnabled: true, } - suite.distrKeeper.SetParams(ctx, params) + suite.NoError(suite.distrKeeper.SetParams(ctx, params)) req = &types.QueryParamsRequest{} expParams = params }, diff --git a/x/distribution/keeper/keeper.go b/x/distribution/keeper/keeper.go index 6af1ede7e5cd..453199037492 100644 --- a/x/distribution/keeper/keeper.go +++ b/x/distribution/keeper/keeper.go @@ -10,48 +10,49 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/distribution/types" - paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" ) // Keeper of the distribution store type Keeper struct { storeKey storetypes.StoreKey cdc codec.BinaryCodec - paramSpace paramtypes.Subspace authKeeper types.AccountKeeper bankKeeper types.BankKeeper stakingKeeper types.StakingKeeper + // the address capable of executing a MsgUpdateParams message. Typically, this + // should be the x/gov module account. + authority string feeCollectorName string // name of the FeeCollector ModuleAccount } // NewKeeper creates a new distribution Keeper instance func NewKeeper( - cdc codec.BinaryCodec, key storetypes.StoreKey, paramSpace paramtypes.Subspace, + cdc codec.BinaryCodec, key storetypes.StoreKey, ak types.AccountKeeper, bk types.BankKeeper, sk types.StakingKeeper, - feeCollectorName string, + feeCollectorName string, authority string, ) Keeper { // ensure distribution module account is set if addr := ak.GetModuleAddress(types.ModuleName); addr == nil { panic(fmt.Sprintf("%s module account has not been set", types.ModuleName)) } - // set KeyTable if it has not already been set - if !paramSpace.HasKeyTable() { - paramSpace = paramSpace.WithKeyTable(types.ParamKeyTable()) - } - return Keeper{ storeKey: key, cdc: cdc, - paramSpace: paramSpace, authKeeper: ak, bankKeeper: bk, stakingKeeper: sk, feeCollectorName: feeCollectorName, + authority: authority, } } +// GetAuthority returns the x/distribution module's authority. +func (k Keeper) GetAuthority() string { + return k.authority +} + // Logger returns a module-specific logger. func (k Keeper) Logger(ctx sdk.Context) log.Logger { return ctx.Logger().With("module", "x/"+types.ModuleName) diff --git a/x/distribution/keeper/keeper_test.go b/x/distribution/keeper/keeper_test.go index 4d671d7329d0..7786928a43a7 100644 --- a/x/distribution/keeper/keeper_test.go +++ b/x/distribution/keeper/keeper_test.go @@ -37,13 +37,13 @@ func TestSetWithdrawAddr(t *testing.T) { params := distrKeeper.GetParams(ctx) params.WithdrawAddrEnabled = false - distrKeeper.SetParams(ctx, params) + require.NoError(t, distrKeeper.SetParams(ctx, params)) err = distrKeeper.SetWithdrawAddr(ctx, addr[0], addr[1]) require.NotNil(t, err) params.WithdrawAddrEnabled = true - distrKeeper.SetParams(ctx, params) + require.NoError(t, distrKeeper.SetParams(ctx, params)) err = distrKeeper.SetWithdrawAddr(ctx, addr[0], addr[1]) require.Nil(t, err) diff --git a/x/distribution/keeper/migrations.go b/x/distribution/keeper/migrations.go index 7439dfbee4ef..cc928e3f79b6 100644 --- a/x/distribution/keeper/migrations.go +++ b/x/distribution/keeper/migrations.go @@ -2,20 +2,31 @@ package keeper import ( sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/distribution/exported" v043 "github.com/cosmos/cosmos-sdk/x/distribution/migrations/v043" + v046 "github.com/cosmos/cosmos-sdk/x/distribution/migrations/v046" ) // Migrator is a struct for handling in-place store migrations. type Migrator struct { - keeper Keeper + keeper Keeper + legacySubspace exported.Subspace } // NewMigrator returns a new Migrator. -func NewMigrator(keeper Keeper) Migrator { - return Migrator{keeper: keeper} +func NewMigrator(keeper Keeper, legacySubspace exported.Subspace) Migrator { + return Migrator{keeper: keeper, legacySubspace: legacySubspace} } // Migrate1to2 migrates from version 1 to 2. func (m Migrator) Migrate1to2(ctx sdk.Context) error { return v043.MigrateStore(ctx, m.keeper.storeKey) } + +// Migrate2to3 migrates the x/distribution module state from the consensus +// version 2 to version 3. Specifically, it takes the parameters that are currently stored +// and managed by the x/params module and stores them directly into the x/distribution +// module state. +func (m Migrator) Migrate2to3(ctx sdk.Context) error { + return v046.MigrateStore(ctx, m.keeper.storeKey, m.legacySubspace, m.keeper.cdc) +} diff --git a/x/distribution/keeper/msg_server.go b/x/distribution/keeper/msg_server.go index 40ba0ce25727..e2b863d892d9 100644 --- a/x/distribution/keeper/msg_server.go +++ b/x/distribution/keeper/msg_server.go @@ -7,21 +7,23 @@ import ( "github.com/cosmos/cosmos-sdk/telemetry" sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/distribution/types" + govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" ) type msgServer struct { Keeper } +var _ types.MsgServer = msgServer{} + // NewMsgServerImpl returns an implementation of the distribution MsgServer interface // for the provided Keeper. func NewMsgServerImpl(keeper Keeper) types.MsgServer { return &msgServer{Keeper: keeper} } -var _ types.MsgServer = msgServer{} - func (k msgServer) SetWithdrawAddress(goCtx context.Context, msg *types.MsgSetWithdrawAddress) (*types.MsgSetWithdrawAddressResponse, error) { ctx := sdk.UnwrapSDKContext(goCtx) @@ -143,3 +145,24 @@ func (k msgServer) FundCommunityPool(goCtx context.Context, msg *types.MsgFundCo return &types.MsgFundCommunityPoolResponse{}, nil } + +func (k msgServer) UpdateParams(goCtx context.Context, req *types.MsgUpdateParams) (*types.MsgUpdateParamsResponse, error) { + if k.authority != req.Authority { + return nil, errors.Wrapf(govtypes.ErrInvalidSigner, "invalid authority; expected %s, got %s", k.authority, req.Authority) + } + + ctx := sdk.UnwrapSDKContext(goCtx) + if err := k.SetParams(ctx, req.Params); err != nil { + return nil, err + } + + ctx.EventManager().EmitEvent( + sdk.NewEvent( + sdk.EventTypeMessage, + sdk.NewAttribute(sdk.AttributeKeyModule, types.AttributeValueCategory), + sdk.NewAttribute(sdk.AttributeKeySender, req.Authority), + ), + ) + + return &types.MsgUpdateParamsResponse{}, nil +} diff --git a/x/distribution/keeper/msg_server_test.go b/x/distribution/keeper/msg_server_test.go new file mode 100644 index 000000000000..fef8c9802294 --- /dev/null +++ b/x/distribution/keeper/msg_server_test.go @@ -0,0 +1,147 @@ +package keeper_test + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/distribution/types" +) + +func (s *KeeperTestSuite) TestMsgUpdateParams() { + // default params + communityTax := sdk.NewDecWithPrec(2, 2) // 2% + baseProposerReward := sdk.NewDecWithPrec(1, 2) // 1% + bonusProposerReward := sdk.NewDecWithPrec(4, 2) // 4% + withdrawAddrEnabled := true + + testCases := []struct { + name string + input *types.MsgUpdateParams + expErr bool + expErrMsg string + }{ + { + name: "invalid authority", + input: &types.MsgUpdateParams{ + Authority: "invalid", + Params: types.Params{ + CommunityTax: sdk.NewDecWithPrec(2, 0), + BaseProposerReward: baseProposerReward, + BonusProposerReward: bonusProposerReward, + WithdrawAddrEnabled: withdrawAddrEnabled, + }, + }, + expErr: true, + expErrMsg: "invalid authority", + }, + { + name: "community tax > 1", + input: &types.MsgUpdateParams{ + Authority: s.distrKeeper.GetAuthority(), + Params: types.Params{ + CommunityTax: sdk.NewDecWithPrec(2, 0), + BaseProposerReward: baseProposerReward, + BonusProposerReward: bonusProposerReward, + WithdrawAddrEnabled: withdrawAddrEnabled, + }, + }, + expErr: true, + expErrMsg: "community tax should be non-negative and less than one", + }, + { + name: "negative community tax", + input: &types.MsgUpdateParams{ + Authority: s.distrKeeper.GetAuthority(), + Params: types.Params{ + CommunityTax: sdk.NewDecWithPrec(-2, 1), + BaseProposerReward: baseProposerReward, + BonusProposerReward: bonusProposerReward, + WithdrawAddrEnabled: withdrawAddrEnabled, + }, + }, + expErr: true, + expErrMsg: "community tax should be non-negative and less than one", + }, + { + name: "base proposer reward > 1", + input: &types.MsgUpdateParams{ + Authority: s.distrKeeper.GetAuthority(), + Params: types.Params{ + CommunityTax: communityTax, + BaseProposerReward: sdk.NewDecWithPrec(2, 0), + BonusProposerReward: bonusProposerReward, + WithdrawAddrEnabled: withdrawAddrEnabled, + }, + }, + expErr: true, + expErrMsg: "sum of base, bonus proposer rewards, and community tax cannot be greater than one", + }, + { + name: "negative base proposer reward", + input: &types.MsgUpdateParams{ + Authority: s.distrKeeper.GetAuthority(), + Params: types.Params{ + CommunityTax: communityTax, + BaseProposerReward: sdk.NewDecWithPrec(-2, 0), + BonusProposerReward: bonusProposerReward, + WithdrawAddrEnabled: withdrawAddrEnabled, + }, + }, + expErr: true, + expErrMsg: "base proposer reward should be positive", + }, + { + name: "bonus proposer reward > 1", + input: &types.MsgUpdateParams{ + Authority: s.distrKeeper.GetAuthority(), + Params: types.Params{ + CommunityTax: communityTax, + BaseProposerReward: baseProposerReward, + BonusProposerReward: sdk.NewDecWithPrec(2, 0), + WithdrawAddrEnabled: withdrawAddrEnabled, + }, + }, + expErr: true, + expErrMsg: "sum of base, bonus proposer rewards, and community tax cannot be greater than one", + }, + { + name: "negative bonus proposer reward", + input: &types.MsgUpdateParams{ + Authority: s.distrKeeper.GetAuthority(), + Params: types.Params{ + CommunityTax: communityTax, + BaseProposerReward: baseProposerReward, + BonusProposerReward: sdk.NewDecWithPrec(-2, 0), + WithdrawAddrEnabled: withdrawAddrEnabled, + }, + }, + expErr: true, + expErrMsg: "bonus proposer reward should be positive", + }, + { + name: "all good", + input: &types.MsgUpdateParams{ + Authority: s.distrKeeper.GetAuthority(), + Params: types.Params{ + CommunityTax: communityTax, + BaseProposerReward: baseProposerReward, + BonusProposerReward: bonusProposerReward, + WithdrawAddrEnabled: withdrawAddrEnabled, + }, + }, + expErr: false, + }, + } + + for _, tc := range testCases { + tc := tc + s.Run(tc.name, func() { + _, err := s.msgServer.UpdateParams(s.ctx, tc.input) + + if tc.expErr { + s.Require().Error(err) + s.Require().Contains(err.Error(), tc.expErrMsg) + } else { + s.Require().NoError(err) + } + }) + } +} diff --git a/x/distribution/keeper/params.go b/x/distribution/keeper/params.go index 23b4bbeb8118..bac1edb5dfb5 100644 --- a/x/distribution/keeper/params.go +++ b/x/distribution/keeper/params.go @@ -7,37 +7,50 @@ import ( // GetParams returns the total set of distribution parameters. func (k Keeper) GetParams(clientCtx sdk.Context) (params types.Params) { - k.paramSpace.GetParamSet(clientCtx, ¶ms) + store := clientCtx.KVStore(k.storeKey) + bz := store.Get(types.ParamsKey) + if bz == nil { + return params + } + + k.cdc.MustUnmarshal(bz, ¶ms) return params } // SetParams sets the distribution parameters to the param space. -func (k Keeper) SetParams(ctx sdk.Context, params types.Params) { - k.paramSpace.SetParamSet(ctx, ¶ms) +func (k Keeper) SetParams(ctx sdk.Context, params types.Params) error { + if err := params.ValidateBasic(); err != nil { + return err + } + + store := ctx.KVStore(k.storeKey) + bz, err := k.cdc.Marshal(¶ms) + if err != nil { + return err + } + store.Set(types.ParamsKey, bz) + + return nil } // GetCommunityTax returns the current distribution community tax. -func (k Keeper) GetCommunityTax(ctx sdk.Context) (percent sdk.Dec) { - k.paramSpace.Get(ctx, types.ParamStoreKeyCommunityTax, &percent) - return percent +func (k Keeper) GetCommunityTax(ctx sdk.Context) sdk.Dec { + return k.GetParams(ctx).CommunityTax } // GetBaseProposerReward returns the current distribution base proposer rate. -func (k Keeper) GetBaseProposerReward(ctx sdk.Context) (percent sdk.Dec) { - k.paramSpace.Get(ctx, types.ParamStoreKeyBaseProposerReward, &percent) - return percent +func (k Keeper) GetBaseProposerReward(ctx sdk.Context) sdk.Dec { + return k.GetParams(ctx).BaseProposerReward } // GetBonusProposerReward returns the current distribution bonus proposer reward // rate. func (k Keeper) GetBonusProposerReward(ctx sdk.Context) (percent sdk.Dec) { - k.paramSpace.Get(ctx, types.ParamStoreKeyBonusProposerReward, &percent) - return percent + return k.GetParams(ctx).BonusProposerReward } // GetWithdrawAddrEnabled returns the current distribution withdraw address // enabled parameter. func (k Keeper) GetWithdrawAddrEnabled(ctx sdk.Context) (enabled bool) { - k.paramSpace.Get(ctx, types.ParamStoreKeyWithdrawAddrEnabled, &enabled) - return enabled + return k.GetParams(ctx).WithdrawAddrEnabled } diff --git a/x/distribution/keeper/params_test.go b/x/distribution/keeper/params_test.go new file mode 100644 index 000000000000..16ae36d69fee --- /dev/null +++ b/x/distribution/keeper/params_test.go @@ -0,0 +1,117 @@ +package keeper_test + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/distribution/types" +) + +func (s *KeeperTestSuite) TestParams() { + // default params + communityTax := sdk.NewDecWithPrec(2, 2) // 2% + baseProposerReward := sdk.NewDecWithPrec(1, 2) // 1% + bonusProposerReward := sdk.NewDecWithPrec(4, 2) // 4% + withdrawAddrEnabled := true + + testCases := []struct { + name string + input types.Params + expErr bool + expErrMsg string + }{ + { + name: "community tax > 1", + input: types.Params{ + CommunityTax: sdk.NewDecWithPrec(2, 0), + BaseProposerReward: baseProposerReward, + BonusProposerReward: bonusProposerReward, + WithdrawAddrEnabled: withdrawAddrEnabled, + }, + expErr: true, + expErrMsg: "community tax should be non-negative and less than one", + }, + { + name: "negative community tax", + input: types.Params{ + CommunityTax: sdk.NewDecWithPrec(-2, 1), + BaseProposerReward: baseProposerReward, + BonusProposerReward: bonusProposerReward, + WithdrawAddrEnabled: withdrawAddrEnabled, + }, + expErr: true, + expErrMsg: "community tax should be non-negative and less than one", + }, + { + name: "base proposer reward > 1", + input: types.Params{ + CommunityTax: communityTax, + BaseProposerReward: sdk.NewDecWithPrec(2, 0), + BonusProposerReward: bonusProposerReward, + WithdrawAddrEnabled: withdrawAddrEnabled, + }, + expErr: true, + expErrMsg: "sum of base, bonus proposer rewards, and community tax cannot be greater than one", + }, + { + name: "negative base proposer reward", + input: types.Params{ + CommunityTax: communityTax, + BaseProposerReward: sdk.NewDecWithPrec(-2, 0), + BonusProposerReward: bonusProposerReward, + WithdrawAddrEnabled: withdrawAddrEnabled, + }, + expErr: true, + expErrMsg: "base proposer reward should be positive", + }, + { + name: "bonus proposer reward > 1", + input: types.Params{ + CommunityTax: communityTax, + BaseProposerReward: baseProposerReward, + BonusProposerReward: sdk.NewDecWithPrec(2, 0), + WithdrawAddrEnabled: withdrawAddrEnabled, + }, + expErr: true, + expErrMsg: "sum of base, bonus proposer rewards, and community tax cannot be greater than one", + }, + { + name: "negative bonus proposer reward", + input: types.Params{ + CommunityTax: communityTax, + BaseProposerReward: baseProposerReward, + BonusProposerReward: sdk.NewDecWithPrec(-2, 0), + WithdrawAddrEnabled: withdrawAddrEnabled, + }, + expErr: true, + expErrMsg: "bonus proposer reward should be positive", + }, + { + name: "all good", + input: types.Params{ + CommunityTax: communityTax, + BaseProposerReward: baseProposerReward, + BonusProposerReward: bonusProposerReward, + WithdrawAddrEnabled: withdrawAddrEnabled, + }, + expErr: false, + }, + } + + for _, tc := range testCases { + tc := tc + s.Run(tc.name, func() { + expected := s.distrKeeper.GetParams(s.ctx) + err := s.distrKeeper.SetParams(s.ctx, tc.input) + + if tc.expErr { + s.Require().Error(err) + s.Require().Contains(err.Error(), tc.expErrMsg) + } else { + expected = tc.input + s.Require().NoError(err) + } + + params := s.distrKeeper.GetParams(s.ctx) + s.Require().Equal(expected, params) + }) + } +} diff --git a/x/distribution/keeper/querier_test.go b/x/distribution/keeper/querier_test.go index 126b55b0a09c..cc739bd6cf95 100644 --- a/x/distribution/keeper/querier_test.go +++ b/x/distribution/keeper/querier_test.go @@ -151,7 +151,7 @@ func TestQueries(t *testing.T) { WithdrawAddrEnabled: true, } - distrKeeper.SetParams(ctx, params) + require.NoError(t, distrKeeper.SetParams(ctx, params)) paramsRes := getQueriedParams(t, ctx, cdc, querier) require.Equal(t, params.CommunityTax, paramsRes.CommunityTax) diff --git a/x/distribution/migrations/v046/migrate.go b/x/distribution/migrations/v046/migrate.go new file mode 100644 index 000000000000..0a4c99a111f1 --- /dev/null +++ b/x/distribution/migrations/v046/migrate.go @@ -0,0 +1,40 @@ +package v046 + +import ( + "github.com/cosmos/cosmos-sdk/codec" + storetypes "github.com/cosmos/cosmos-sdk/store/types" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/distribution/exported" + "github.com/cosmos/cosmos-sdk/x/distribution/types" +) + +const ( + ModuleName = "distribution" +) + +var ( + ParamsKey = []byte{0x09} +) + +// MigrateStore migrates the x/distribution module state from the consensus version 2 to +// version 3. Specifically, it takes the parameters that are currently stored +// and managed by the x/params module and stores them directly into the x/distribution +// module state. +func MigrateStore(ctx sdk.Context, storeKey storetypes.StoreKey, legacySubspace exported.Subspace, cdc codec.BinaryCodec) error { + store := ctx.KVStore(storeKey) + var currParams types.Params + legacySubspace.GetParamSet(ctx, &currParams) + + if err := currParams.ValidateBasic(); err != nil { + return err + } + + bz, err := cdc.Marshal(&currParams) + if err != nil { + return err + } + + store.Set(ParamsKey, bz) + + return nil +} diff --git a/x/distribution/migrations/v046/migrate_test.go b/x/distribution/migrations/v046/migrate_test.go new file mode 100644 index 000000000000..56bf5df0447b --- /dev/null +++ b/x/distribution/migrations/v046/migrate_test.go @@ -0,0 +1,44 @@ +package v046_test + +import ( + "testing" + + "github.com/cosmos/cosmos-sdk/testutil" + sdk "github.com/cosmos/cosmos-sdk/types" + moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil" + "github.com/cosmos/cosmos-sdk/x/distribution" + "github.com/cosmos/cosmos-sdk/x/distribution/exported" + v046 "github.com/cosmos/cosmos-sdk/x/distribution/migrations/v046" + "github.com/cosmos/cosmos-sdk/x/distribution/types" + "github.com/stretchr/testify/require" +) + +type mockSubspace struct { + ps types.Params +} + +func newMockSubspace(ps types.Params) mockSubspace { + return mockSubspace{ps: ps} +} + +func (ms mockSubspace) GetParamSet(ctx sdk.Context, ps exported.ParamSet) { + *ps.(*types.Params) = ms.ps +} + +func TestMigrate(t *testing.T) { + encCfg := moduletestutil.MakeTestEncodingConfig(distribution.AppModuleBasic{}) + cdc := encCfg.Codec + + storeKey := sdk.NewKVStoreKey(v046.ModuleName) + tKey := sdk.NewTransientStoreKey("transient_test") + ctx := testutil.DefaultContext(storeKey, tKey) + store := ctx.KVStore(storeKey) + + legacySubspace := newMockSubspace(types.DefaultParams()) + require.NoError(t, v046.MigrateStore(ctx, storeKey, legacySubspace, cdc)) + + var res types.Params + bz := store.Get(v046.ParamsKey) + require.NoError(t, cdc.Unmarshal(bz, &res)) + require.Equal(t, legacySubspace.ps, res) +} diff --git a/x/distribution/module.go b/x/distribution/module.go index c303b2712e44..be9b7f5e08e4 100644 --- a/x/distribution/module.go +++ b/x/distribution/module.go @@ -26,11 +26,15 @@ import ( "github.com/cosmos/cosmos-sdk/x/distribution/keeper" "github.com/cosmos/cosmos-sdk/x/distribution/simulation" "github.com/cosmos/cosmos-sdk/x/distribution/types" + govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" govv1beta1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1beta1" paramstypes "github.com/cosmos/cosmos-sdk/x/params/types" staking "github.com/cosmos/cosmos-sdk/x/staking/types" ) +// ConsensusVersion defines the current x/distribution module consensus version. +const ConsensusVersion = 3 + var ( _ module.AppModule = AppModule{} _ module.AppModuleBasic = AppModuleBasic{} @@ -98,12 +102,15 @@ type AppModule struct { accountKeeper types.AccountKeeper bankKeeper types.BankKeeper stakingKeeper types.StakingKeeper + + // legacySubspace is used solely for migration of x/params managed parameters + legacySubspace paramstypes.Subspace } // NewAppModule creates a new AppModule object func NewAppModule( cdc codec.Codec, keeper keeper.Keeper, accountKeeper types.AccountKeeper, - bankKeeper types.BankKeeper, stakingKeeper types.StakingKeeper, + bankKeeper types.BankKeeper, stakingKeeper types.StakingKeeper, ss paramstypes.Subspace, ) AppModule { return AppModule{ AppModuleBasic: AppModuleBasic{cdc: cdc}, @@ -111,6 +118,7 @@ func NewAppModule( accountKeeper: accountKeeper, bankKeeper: bankKeeper, stakingKeeper: stakingKeeper, + legacySubspace: ss, } } @@ -144,8 +152,14 @@ func (am AppModule) RegisterServices(cfg module.Configurator) { types.RegisterMsgServer(cfg.MsgServer(), keeper.NewMsgServerImpl(am.keeper)) types.RegisterQueryServer(cfg.QueryServer(), am.keeper) - m := keeper.NewMigrator(am.keeper) - cfg.RegisterMigration(types.ModuleName, 1, m.Migrate1to2) + m := keeper.NewMigrator(am.keeper, am.legacySubspace) + if err := cfg.RegisterMigration(types.ModuleName, 1, m.Migrate1to2); err != nil { + panic(fmt.Sprintf("failed to migrate x/%s from version 1 to 2: %v", types.ModuleName, err)) + } + + if err := cfg.RegisterMigration(types.ModuleName, 2, m.Migrate2to3); err != nil { + panic(fmt.Sprintf("failed to migrate x/%s from version 2 to 3: %v", types.ModuleName, err)) + } } // InitGenesis performs genesis initialization for the distribution module. It returns @@ -165,7 +179,7 @@ func (am AppModule) ExportGenesis(ctx sdk.Context, cdc codec.JSONCodec) json.Raw } // ConsensusVersion implements AppModule/ConsensusVersion. -func (AppModule) ConsensusVersion() uint64 { return 2 } +func (AppModule) ConsensusVersion() uint64 { return ConsensusVersion } // BeginBlock returns the begin blocker for the distribution module. func (am AppModule) BeginBlock(ctx sdk.Context, req abci.RequestBeginBlock) { @@ -192,8 +206,12 @@ func (am AppModule) ProposalContents(simState module.SimulationState) []simtypes } // RandomizedParams creates randomized distribution param changes for the simulator. -func (AppModule) RandomizedParams(r *rand.Rand) []simtypes.ParamChange { - return simulation.ParamChanges(r) + +// TODO: Returns an empty slice which will make parameter changes a no-op during +// simulations. Once all modules are migrated, remove RandomizedParams from +// the simulation interface. +func (AppModule) RandomizedParams(_ *rand.Rand) []simtypes.ParamChange { + return []simtypes.ParamChange{} } // RegisterStoreDecoder registers a decoder for distribution module's types @@ -225,14 +243,16 @@ func provideModuleBasic() runtime.AppModuleBasicWrapper { type distrInputs struct { depinject.In - Config *modulev1.Module - Key *store.KVStoreKey - Cdc codec.Codec - Subspace paramstypes.Subspace + Config *modulev1.Module + Key *store.KVStoreKey + Cdc codec.Codec AccountKeeper types.AccountKeeper BankKeeper types.BankKeeper StakingKeeper types.StakingKeeper + + // LegacySubspace is used solely for migration of x/params managed parameters + LegacySubspace paramstypes.Subspace } type distrOutputs struct { @@ -250,8 +270,17 @@ func provideModule(in distrInputs) distrOutputs { feeCollectorName = authtypes.FeeCollectorName } - k := keeper.NewKeeper(in.Cdc, in.Key, in.Subspace, in.AccountKeeper, in.BankKeeper, in.StakingKeeper, feeCollectorName) - m := NewAppModule(in.Cdc, k, in.AccountKeeper, in.BankKeeper, in.StakingKeeper) + k := keeper.NewKeeper( + in.Cdc, + in.Key, + in.AccountKeeper, + in.BankKeeper, + in.StakingKeeper, + feeCollectorName, + authtypes.NewModuleAddress(govtypes.ModuleName).String(), + ) + + m := NewAppModule(in.Cdc, k, in.AccountKeeper, in.BankKeeper, in.StakingKeeper, in.LegacySubspace) return distrOutputs{ DistrKeeper: k, diff --git a/x/distribution/spec/02_state.md b/x/distribution/spec/02_state.md index e914ce25364d..ec79f2aae5a1 100644 --- a/x/distribution/spec/02_state.md +++ b/x/distribution/spec/02_state.md @@ -63,3 +63,12 @@ type DelegationDistInfo struct { WithdrawalHeight int64 // last time this delegation withdrew rewards } ``` + +## Params + +distribution module stores it's params in state with the prefix of `0x09`, +it can only updated with governance. + +* Params: `0x09 | ProtocolBuffer(Params)` + ++++ https://github.com/cosmos/cosmos-sdk/blob/v0.46.0-rc1/proto/cosmos/distribution/v1beta1/distribution.proto#L11-L30 diff --git a/x/distribution/spec/04_messages.md b/x/distribution/spec/04_messages.md index 87d608842e5b..406b6d9b8bb9 100644 --- a/x/distribution/spec/04_messages.md +++ b/x/distribution/spec/04_messages.md @@ -120,3 +120,13 @@ func (k Keeper) initializeDelegation(ctx sdk.Context, val sdk.ValAddress, del sd k.SetDelegatorStartingInfo(ctx, val, del, types.NewDelegatorStartingInfo(previousPeriod, stake, uint64(ctx.BlockHeight()))) } ``` + +## MsgUpdateParams + +Distribution module params can be updated through `MsgUpdateParams`, which can be done using governance proposal and the signer will always be gov module account address. + ++++ https://github.com/cosmos/cosmos-sdk/blob/8822ef2695a1eb8cb30b7432f58f631c73951f1d/proto/cosmos/distribution/v1beta1/tx.proto#L106-L119 + +The message handling can fail if: + +* signer is not the gov module account address. diff --git a/x/distribution/types/codec.go b/x/distribution/types/codec.go index 0bff07d87340..4180513eef58 100644 --- a/x/distribution/types/codec.go +++ b/x/distribution/types/codec.go @@ -18,6 +18,9 @@ func RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) { legacy.RegisterAminoMsg(cdc, &MsgWithdrawValidatorCommission{}, "cosmos-sdk/MsgWithdrawValCommission") legacy.RegisterAminoMsg(cdc, &MsgSetWithdrawAddress{}, "cosmos-sdk/MsgModifyWithdrawAddress") legacy.RegisterAminoMsg(cdc, &MsgFundCommunityPool{}, "cosmos-sdk/MsgFundCommunityPool") + legacy.RegisterAminoMsg(cdc, &MsgUpdateParams{}, "cosmos-sdk/distribution/MsgUpdateParams") + + cdc.RegisterConcrete(Params{}, "cosmos-sdk/x/distribution/Params", nil) cdc.RegisterConcrete(&CommunityPoolSpendProposal{}, "cosmos-sdk/CommunityPoolSpendProposal", nil) } @@ -28,6 +31,7 @@ func RegisterInterfaces(registry types.InterfaceRegistry) { &MsgWithdrawValidatorCommission{}, &MsgSetWithdrawAddress{}, &MsgFundCommunityPool{}, + &MsgUpdateParams{}, ) registry.RegisterImplementations( (*govtypes.Content)(nil), diff --git a/x/distribution/types/genesis.pb.go b/x/distribution/types/genesis.pb.go index a1f2d7ba7b70..59014e032a67 100644 --- a/x/distribution/types/genesis.pb.go +++ b/x/distribution/types/genesis.pb.go @@ -327,7 +327,7 @@ var xxx_messageInfo_ValidatorSlashEventRecord proto.InternalMessageInfo // GenesisState defines the distribution module's genesis state. type GenesisState struct { - // params defines all the paramaters of the module. + // params defines all the parameters of the module. Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"` // fee_pool defines the fee pool at genesis. FeePool FeePool `protobuf:"bytes,2,opt,name=fee_pool,json=feePool,proto3" json:"fee_pool"` diff --git a/x/distribution/types/keys.go b/x/distribution/types/keys.go index e0458459d080..e5e182f5ac8c 100644 --- a/x/distribution/types/keys.go +++ b/x/distribution/types/keys.go @@ -42,6 +42,8 @@ const ( // - 0x07: ValidatorCurrentCommission // // - 0x08: ValidatorSlashEvent +// +// - 0x09: Params var ( FeePoolKey = []byte{0x00} // key for global distribution state ProposerKey = []byte{0x01} // key for the proposer operator address @@ -53,6 +55,8 @@ var ( ValidatorCurrentRewardsPrefix = []byte{0x06} // key for current validator rewards ValidatorAccumulatedCommissionPrefix = []byte{0x07} // key for accumulated validator commission ValidatorSlashEventPrefix = []byte{0x08} // key for validator slash fraction + + ParamsKey = []byte{0x09} // key for distribution module params ) // GetValidatorOutstandingRewardsAddress creates an address from a validator's outstanding rewards key. diff --git a/x/distribution/types/msg.go b/x/distribution/types/msg.go index 2071ca0282e8..36dc021e0486 100644 --- a/x/distribution/types/msg.go +++ b/x/distribution/types/msg.go @@ -11,10 +11,11 @@ const ( TypeMsgWithdrawDelegatorReward = "withdraw_delegator_reward" TypeMsgWithdrawValidatorCommission = "withdraw_validator_commission" TypeMsgFundCommunityPool = "fund_community_pool" + TypeMsgUpdateParams = "update_params" ) // Verify interface at compile time -var _, _, _ sdk.Msg = &MsgSetWithdrawAddress{}, &MsgWithdrawDelegatorReward{}, &MsgWithdrawValidatorCommission{} +var _, _, _, _ sdk.Msg = &MsgSetWithdrawAddress{}, &MsgWithdrawDelegatorReward{}, &MsgWithdrawValidatorCommission{}, &MsgUpdateParams{} func NewMsgSetWithdrawAddress(delAddr, withdrawAddr sdk.AccAddress) *MsgSetWithdrawAddress { return &MsgSetWithdrawAddress{ @@ -151,3 +152,28 @@ func (msg MsgFundCommunityPool) ValidateBasic() error { } return nil } + +// Route returns the MsgUpdateParams message route. +func (msg MsgUpdateParams) Route() string { return ModuleName } + +// Type returns the MsgUpdateParams message type. +func (msg MsgUpdateParams) Type() string { return TypeMsgUpdateParams } + +// GetSigners returns the signer addresses that are expected to sign the result +// of GetSignBytes. +func (msg MsgUpdateParams) GetSigners() []sdk.AccAddress { + authority, _ := sdk.AccAddressFromBech32(msg.Authority) + return []sdk.AccAddress{authority} +} + +// GetSignBytes returns the raw bytes for a MsgUpdateParams message that +// the expected signer needs to sign. +func (msg MsgUpdateParams) GetSignBytes() []byte { + bz := ModuleCdc.MustMarshalJSON(&msg) + return sdk.MustSortJSON(bz) +} + +// ValidateBasic performs basic MsgUpdateParams message validation. +func (msg MsgUpdateParams) ValidateBasic() error { + return msg.Params.ValidateBasic() +} diff --git a/x/distribution/types/params.go b/x/distribution/types/params.go index a4ea2ddea005..3a780dee8610 100644 --- a/x/distribution/types/params.go +++ b/x/distribution/types/params.go @@ -6,22 +6,8 @@ import ( "sigs.k8s.io/yaml" sdk "github.com/cosmos/cosmos-sdk/types" - paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" ) -// Parameter keys -var ( - ParamStoreKeyCommunityTax = []byte("communitytax") - ParamStoreKeyBaseProposerReward = []byte("baseproposerreward") - ParamStoreKeyBonusProposerReward = []byte("bonusproposerreward") - ParamStoreKeyWithdrawAddrEnabled = []byte("withdrawaddrenabled") -) - -// ParamKeyTable returns the parameter key table. -func ParamKeyTable() paramtypes.KeyTable { - return paramtypes.NewKeyTable().RegisterParamSet(&Params{}) -} - // DefaultParams returns default distribution parameters func DefaultParams() Params { return Params{ @@ -37,16 +23,6 @@ func (p Params) String() string { return string(out) } -// ParamSetPairs returns the parameter set pairs. -func (p *Params) ParamSetPairs() paramtypes.ParamSetPairs { - return paramtypes.ParamSetPairs{ - paramtypes.NewParamSetPair(ParamStoreKeyCommunityTax, &p.CommunityTax, validateCommunityTax), - paramtypes.NewParamSetPair(ParamStoreKeyBaseProposerReward, &p.BaseProposerReward, validateBaseProposerReward), - paramtypes.NewParamSetPair(ParamStoreKeyBonusProposerReward, &p.BonusProposerReward, validateBonusProposerReward), - paramtypes.NewParamSetPair(ParamStoreKeyWithdrawAddrEnabled, &p.WithdrawAddrEnabled, validateWithdrawAddrEnabled), - } -} - // ValidateBasic performs basic validation on distribution parameters. func (p Params) ValidateBasic() error { if p.CommunityTax.IsNegative() || p.CommunityTax.GT(sdk.OneDec()) { diff --git a/x/distribution/types/params_legacy.go b/x/distribution/types/params_legacy.go new file mode 100644 index 000000000000..f82901383df1 --- /dev/null +++ b/x/distribution/types/params_legacy.go @@ -0,0 +1,26 @@ +package types + +import paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" + +// Parameter keys +var ( + ParamStoreKeyCommunityTax = []byte("communitytax") + ParamStoreKeyBaseProposerReward = []byte("baseproposerreward") + ParamStoreKeyBonusProposerReward = []byte("bonusproposerreward") + ParamStoreKeyWithdrawAddrEnabled = []byte("withdrawaddrenabled") +) + +// ParamKeyTable returns the parameter key table. +func ParamKeyTable() paramtypes.KeyTable { + return paramtypes.NewKeyTable().RegisterParamSet(&Params{}) +} + +// ParamSetPairs returns the parameter set pairs. +func (p *Params) ParamSetPairs() paramtypes.ParamSetPairs { + return paramtypes.ParamSetPairs{ + paramtypes.NewParamSetPair(ParamStoreKeyCommunityTax, &p.CommunityTax, validateCommunityTax), + paramtypes.NewParamSetPair(ParamStoreKeyBaseProposerReward, &p.BaseProposerReward, validateBaseProposerReward), + paramtypes.NewParamSetPair(ParamStoreKeyBonusProposerReward, &p.BonusProposerReward, validateBonusProposerReward), + paramtypes.NewParamSetPair(ParamStoreKeyWithdrawAddrEnabled, &p.WithdrawAddrEnabled, validateWithdrawAddrEnabled), + } +} diff --git a/x/distribution/types/tx.pb.go b/x/distribution/types/tx.pb.go index 0eaca3be21c9..a0d2bb14f58d 100644 --- a/x/distribution/types/tx.pb.go +++ b/x/distribution/types/tx.pb.go @@ -359,6 +359,105 @@ func (m *MsgFundCommunityPoolResponse) XXX_DiscardUnknown() { var xxx_messageInfo_MsgFundCommunityPoolResponse proto.InternalMessageInfo +// MsgUpdateParams is the Msg/UpdateParams request type. +// +// Since: cosmos-sdk 0.47 +type MsgUpdateParams struct { + // authority is the address of the governance account. + Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"` + // params defines the x/distribution parameters to update. + // + // NOTE: All parameters must be supplied. + Params Params `protobuf:"bytes,2,opt,name=params,proto3" json:"params"` +} + +func (m *MsgUpdateParams) Reset() { *m = MsgUpdateParams{} } +func (m *MsgUpdateParams) String() string { return proto.CompactTextString(m) } +func (*MsgUpdateParams) ProtoMessage() {} +func (*MsgUpdateParams) Descriptor() ([]byte, []int) { + return fileDescriptor_ed4f433d965e58ca, []int{8} +} +func (m *MsgUpdateParams) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgUpdateParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgUpdateParams.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *MsgUpdateParams) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgUpdateParams.Merge(m, src) +} +func (m *MsgUpdateParams) XXX_Size() int { + return m.Size() +} +func (m *MsgUpdateParams) XXX_DiscardUnknown() { + xxx_messageInfo_MsgUpdateParams.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgUpdateParams proto.InternalMessageInfo + +func (m *MsgUpdateParams) GetAuthority() string { + if m != nil { + return m.Authority + } + return "" +} + +func (m *MsgUpdateParams) GetParams() Params { + if m != nil { + return m.Params + } + return Params{} +} + +// MsgUpdateParamsResponse defines the response structure for executing a +// MsgUpdateParams message. +// +// Since: cosmos-sdk 0.47 +type MsgUpdateParamsResponse struct { +} + +func (m *MsgUpdateParamsResponse) Reset() { *m = MsgUpdateParamsResponse{} } +func (m *MsgUpdateParamsResponse) String() string { return proto.CompactTextString(m) } +func (*MsgUpdateParamsResponse) ProtoMessage() {} +func (*MsgUpdateParamsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_ed4f433d965e58ca, []int{9} +} +func (m *MsgUpdateParamsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgUpdateParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgUpdateParamsResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *MsgUpdateParamsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgUpdateParamsResponse.Merge(m, src) +} +func (m *MsgUpdateParamsResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgUpdateParamsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgUpdateParamsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgUpdateParamsResponse proto.InternalMessageInfo + func init() { proto.RegisterType((*MsgSetWithdrawAddress)(nil), "cosmos.distribution.v1beta1.MsgSetWithdrawAddress") proto.RegisterType((*MsgSetWithdrawAddressResponse)(nil), "cosmos.distribution.v1beta1.MsgSetWithdrawAddressResponse") @@ -368,6 +467,8 @@ func init() { proto.RegisterType((*MsgWithdrawValidatorCommissionResponse)(nil), "cosmos.distribution.v1beta1.MsgWithdrawValidatorCommissionResponse") proto.RegisterType((*MsgFundCommunityPool)(nil), "cosmos.distribution.v1beta1.MsgFundCommunityPool") proto.RegisterType((*MsgFundCommunityPoolResponse)(nil), "cosmos.distribution.v1beta1.MsgFundCommunityPoolResponse") + proto.RegisterType((*MsgUpdateParams)(nil), "cosmos.distribution.v1beta1.MsgUpdateParams") + proto.RegisterType((*MsgUpdateParamsResponse)(nil), "cosmos.distribution.v1beta1.MsgUpdateParamsResponse") } func init() { @@ -375,44 +476,50 @@ func init() { } var fileDescriptor_ed4f433d965e58ca = []byte{ - // 589 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x55, 0x41, 0x6b, 0x13, 0x41, - 0x14, 0xde, 0xb1, 0x52, 0xe8, 0x78, 0x30, 0x59, 0xa2, 0x4d, 0xb7, 0x3a, 0x29, 0x8b, 0x48, 0x10, - 0xba, 0x6b, 0x22, 0x28, 0xc6, 0x83, 0x98, 0x58, 0x6f, 0x41, 0x49, 0x41, 0xc1, 0x4b, 0xd9, 0x64, - 0x86, 0xe9, 0x60, 0x76, 0x27, 0xec, 0x4c, 0x92, 0xf6, 0xa8, 0x08, 0xea, 0x41, 0x10, 0xfc, 0x01, - 0xf6, 0x28, 0x9e, 0x3c, 0xf8, 0x0f, 0xbc, 0x04, 0xbd, 0x14, 0x4f, 0x9e, 0x54, 0x92, 0x83, 0xfe, - 0x0c, 0x49, 0x76, 0x76, 0x9b, 0x90, 0x4d, 0xb6, 0xb5, 0xd2, 0xd3, 0x2c, 0xf3, 0xde, 0xf7, 0xcd, - 0xf7, 0xbd, 0x7d, 0x6f, 0x06, 0x5e, 0x6a, 0x70, 0xe1, 0x72, 0x61, 0x63, 0x26, 0xa4, 0xcf, 0xea, - 0x6d, 0xc9, 0xb8, 0x67, 0x77, 0x0a, 0x75, 0x22, 0x9d, 0x82, 0x2d, 0x77, 0xac, 0x96, 0xcf, 0x25, - 0xd7, 0x57, 0x83, 0x2c, 0x6b, 0x3c, 0xcb, 0x52, 0x59, 0x46, 0x86, 0x72, 0xca, 0x47, 0x79, 0xf6, - 0xf0, 0x2b, 0x80, 0x18, 0x48, 0x11, 0xd7, 0x1d, 0x41, 0x22, 0xc2, 0x06, 0x67, 0x9e, 0x8a, 0xaf, - 0x04, 0xf1, 0xad, 0x00, 0xa8, 0xf8, 0x83, 0xd0, 0xb2, 0x82, 0xba, 0x82, 0xda, 0x9d, 0xc2, 0x70, - 0x09, 0x02, 0xe6, 0x67, 0x00, 0xcf, 0x55, 0x05, 0xdd, 0x24, 0xf2, 0x11, 0x93, 0xdb, 0xd8, 0x77, - 0xba, 0x77, 0x30, 0xf6, 0x89, 0x10, 0xfa, 0x06, 0x4c, 0x63, 0xd2, 0x24, 0xd4, 0x91, 0xdc, 0xdf, - 0x72, 0x82, 0xcd, 0x2c, 0x58, 0x03, 0xf9, 0xa5, 0x72, 0xf6, 0xdb, 0xa7, 0xf5, 0x8c, 0xe2, 0x57, - 0xe9, 0x9b, 0xd2, 0x67, 0x1e, 0xad, 0xa5, 0x22, 0x48, 0x48, 0x53, 0x81, 0xa9, 0xae, 0x62, 0x8e, - 0x58, 0x4e, 0x25, 0xb0, 0x9c, 0xed, 0x4e, 0x6a, 0x29, 0xa1, 0x97, 0x7b, 0x39, 0xed, 0xcf, 0x5e, - 0x4e, 0x7b, 0xf6, 0xfb, 0xe3, 0x95, 0x69, 0x59, 0x66, 0x0e, 0x5e, 0x8c, 0x35, 0x51, 0x23, 0xa2, - 0xc5, 0x3d, 0x41, 0xcc, 0x2f, 0x00, 0x1a, 0x55, 0x41, 0xc3, 0xf0, 0xdd, 0x90, 0xa1, 0x46, 0xba, - 0x8e, 0x8f, 0xff, 0x97, 0xd7, 0x0d, 0x98, 0xee, 0x38, 0x4d, 0x86, 0x27, 0x68, 0x92, 0xcc, 0xa6, - 0x22, 0xc8, 0x61, 0xdd, 0xbe, 0x02, 0xd0, 0x9c, 0x6d, 0x26, 0xf4, 0xac, 0x37, 0xe0, 0xa2, 0xe3, - 0xf2, 0xb6, 0x27, 0xb3, 0x60, 0x6d, 0x21, 0x7f, 0xa6, 0xb8, 0x62, 0xa9, 0xf3, 0x87, 0xfd, 0x13, - 0xb6, 0x9a, 0x55, 0xe1, 0xcc, 0x2b, 0x5f, 0xed, 0xfd, 0xc8, 0x69, 0x1f, 0x7e, 0xe6, 0xf2, 0x94, - 0xc9, 0xed, 0x76, 0xdd, 0x6a, 0x70, 0x57, 0xf5, 0x8f, 0x5a, 0xd6, 0x05, 0x7e, 0x62, 0xcb, 0xdd, - 0x16, 0x11, 0x23, 0x80, 0xa8, 0x29, 0x6a, 0xf3, 0x05, 0x80, 0x68, 0x4c, 0xcb, 0xc3, 0xd0, 0x4b, - 0x85, 0xbb, 0x2e, 0x13, 0x82, 0x71, 0x2f, 0xbe, 0x2a, 0xe0, 0x98, 0x55, 0x99, 0x62, 0x34, 0x5f, - 0x03, 0x78, 0x79, 0xbe, 0x92, 0x93, 0xad, 0xcc, 0x57, 0x00, 0x33, 0x55, 0x41, 0xef, 0xb5, 0x3d, - 0x3c, 0x94, 0xd0, 0xf6, 0x98, 0xdc, 0x7d, 0xc0, 0x79, 0xf3, 0x44, 0x4e, 0xd7, 0xaf, 0xc3, 0x25, - 0x4c, 0x5a, 0x5c, 0x30, 0xc9, 0xfd, 0xc4, 0x16, 0x3c, 0x48, 0x2d, 0x9d, 0x1f, 0xaf, 0xf2, 0xc1, - 0xbe, 0x89, 0xe0, 0x85, 0x38, 0x33, 0x61, 0x49, 0x8b, 0xbd, 0xd3, 0x70, 0xa1, 0x2a, 0xa8, 0xfe, - 0x1c, 0x40, 0x3d, 0xe6, 0x32, 0x29, 0x5a, 0x73, 0xae, 0x3b, 0x2b, 0x76, 0x76, 0x8d, 0xd2, 0xd1, - 0x31, 0xd1, 0x1f, 0x7e, 0x0b, 0xe0, 0xf2, 0xac, 0x61, 0xbf, 0x91, 0xc4, 0x3b, 0x03, 0x68, 0xdc, - 0xfe, 0x47, 0x60, 0xa4, 0xea, 0x1d, 0x80, 0xab, 0xf3, 0x26, 0xe5, 0xd6, 0x61, 0x0f, 0x88, 0x01, - 0x1b, 0x95, 0x63, 0x80, 0x23, 0x85, 0x4f, 0x01, 0x4c, 0x4f, 0x77, 0x6c, 0x21, 0x89, 0x7a, 0x0a, - 0x62, 0xdc, 0x3c, 0x32, 0x24, 0xd4, 0x50, 0xbe, 0xff, 0xbe, 0x8f, 0x40, 0xaf, 0x8f, 0xc0, 0x7e, - 0x1f, 0x81, 0x5f, 0x7d, 0x04, 0xde, 0x0c, 0x90, 0xb6, 0x3f, 0x40, 0xda, 0xf7, 0x01, 0xd2, 0x1e, - 0x17, 0xe6, 0x8e, 0xc2, 0xce, 0xe4, 0xab, 0x3b, 0x9a, 0x8c, 0xfa, 0xe2, 0xe8, 0xa9, 0xbb, 0xf6, - 0x37, 0x00, 0x00, 0xff, 0xff, 0x8b, 0x65, 0x3b, 0xae, 0x99, 0x07, 0x00, 0x00, + // 680 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x56, 0x41, 0x6b, 0xd4, 0x40, + 0x14, 0xce, 0x58, 0x2d, 0x74, 0x2a, 0xb6, 0x0d, 0xd5, 0xb6, 0xa9, 0x66, 0x4b, 0x14, 0x29, 0x62, + 0x13, 0x77, 0x15, 0xc5, 0xf5, 0x20, 0xdd, 0xb5, 0xde, 0x16, 0xcb, 0x16, 0x15, 0xbc, 0x94, 0xd9, + 0xcd, 0x90, 0x0e, 0x36, 0x99, 0x90, 0x99, 0x74, 0xdb, 0xa3, 0x22, 0xa8, 0x07, 0x41, 0xf0, 0x2a, + 0xd8, 0xa3, 0x78, 0xf2, 0xe0, 0xd1, 0x9b, 0x97, 0xa2, 0x97, 0xe2, 0xc9, 0x93, 0xca, 0xf6, 0xa0, + 0x3f, 0x43, 0x92, 0x4c, 0xd2, 0x5d, 0x37, 0x4d, 0xba, 0x56, 0x7a, 0xca, 0x92, 0xf7, 0x7d, 0xdf, + 0xfb, 0xde, 0xdb, 0xf7, 0x1e, 0x81, 0xe7, 0x9a, 0x94, 0xd9, 0x94, 0x19, 0x26, 0x61, 0xdc, 0x23, + 0x0d, 0x9f, 0x13, 0xea, 0x18, 0x6b, 0xc5, 0x06, 0xe6, 0xa8, 0x68, 0xf0, 0x75, 0xdd, 0xf5, 0x28, + 0xa7, 0xf2, 0x74, 0x84, 0xd2, 0x3b, 0x51, 0xba, 0x40, 0x29, 0xe3, 0x16, 0xb5, 0x68, 0x88, 0x33, + 0x82, 0x5f, 0x11, 0x45, 0x51, 0x85, 0x70, 0x03, 0x31, 0x9c, 0x08, 0x36, 0x29, 0x71, 0x44, 0x7c, + 0x2a, 0x8a, 0x2f, 0x47, 0x44, 0xa1, 0x1f, 0x85, 0x26, 0x04, 0xd5, 0x66, 0x96, 0xb1, 0x56, 0x0c, + 0x1e, 0x22, 0xa0, 0x67, 0x99, 0xed, 0xf2, 0x16, 0xe2, 0xb5, 0x4f, 0x00, 0x9e, 0xac, 0x31, 0x6b, + 0x09, 0xf3, 0xfb, 0x84, 0xaf, 0x98, 0x1e, 0x6a, 0xcd, 0x9b, 0xa6, 0x87, 0x19, 0x93, 0x17, 0xe0, + 0x98, 0x89, 0x57, 0xb1, 0x85, 0x38, 0xf5, 0x96, 0x51, 0xf4, 0x72, 0x12, 0xcc, 0x80, 0xd9, 0xa1, + 0xca, 0xe4, 0xd7, 0x0f, 0x73, 0xe3, 0xc2, 0x8f, 0x80, 0x2f, 0x71, 0x8f, 0x38, 0x56, 0x7d, 0x34, + 0xa1, 0xc4, 0x32, 0x55, 0x38, 0xda, 0x12, 0xca, 0x89, 0xca, 0x91, 0x1c, 0x95, 0x91, 0x56, 0xb7, + 0x97, 0xb2, 0xfa, 0x6c, 0xb3, 0x20, 0xfd, 0xde, 0x2c, 0x48, 0x8f, 0x7f, 0xbd, 0xbf, 0xd0, 0x6b, + 0x4b, 0x2b, 0xc0, 0x33, 0xa9, 0x45, 0xd4, 0x31, 0x73, 0xa9, 0xc3, 0xb0, 0xf6, 0x19, 0x40, 0xa5, + 0xc6, 0xac, 0x38, 0x7c, 0x2b, 0x56, 0xa8, 0xe3, 0x16, 0xf2, 0xcc, 0xff, 0x55, 0xeb, 0x02, 0x1c, + 0x5b, 0x43, 0xab, 0xc4, 0xec, 0x92, 0xc9, 0x2b, 0x76, 0x34, 0xa1, 0xec, 0xb7, 0xda, 0xe7, 0x00, + 0x6a, 0x7b, 0x17, 0x13, 0xd7, 0x2c, 0x37, 0xe1, 0x20, 0xb2, 0xa9, 0xef, 0xf0, 0x49, 0x30, 0x33, + 0x30, 0x3b, 0x5c, 0x9a, 0x12, 0xb3, 0xa1, 0x07, 0xf3, 0x16, 0x8f, 0xa6, 0x5e, 0xa5, 0xc4, 0xa9, + 0x5c, 0xda, 0xfa, 0x5e, 0x90, 0xde, 0xfd, 0x28, 0xcc, 0x5a, 0x84, 0xaf, 0xf8, 0x0d, 0xbd, 0x49, + 0x6d, 0x31, 0x6f, 0xe2, 0x31, 0xc7, 0xcc, 0x87, 0x06, 0xdf, 0x70, 0x31, 0x0b, 0x09, 0xac, 0x2e, + 0xa4, 0xb5, 0xa7, 0x00, 0xaa, 0x1d, 0x5e, 0xee, 0xc5, 0xb5, 0x54, 0xa9, 0x6d, 0x13, 0xc6, 0x08, + 0x75, 0xd2, 0xbb, 0x02, 0x0e, 0xd8, 0x95, 0x1e, 0x45, 0xed, 0x05, 0x80, 0xe7, 0xb3, 0x9d, 0x1c, + 0x6e, 0x67, 0xbe, 0x00, 0x38, 0x5e, 0x63, 0xd6, 0x6d, 0xdf, 0x31, 0x03, 0x0b, 0xbe, 0x43, 0xf8, + 0xc6, 0x22, 0xa5, 0xab, 0x87, 0x92, 0x5d, 0xbe, 0x0a, 0x87, 0x4c, 0xec, 0x52, 0x46, 0x38, 0xf5, + 0x72, 0x47, 0x70, 0x17, 0x5a, 0x3e, 0xd5, 0xd9, 0xe5, 0xdd, 0xf7, 0x9a, 0x0a, 0x4f, 0xa7, 0x15, + 0x93, 0x2c, 0xd8, 0x6b, 0x00, 0x47, 0x6a, 0xcc, 0xba, 0xeb, 0x9a, 0x88, 0xe3, 0x45, 0xe4, 0x21, + 0x9b, 0x05, 0x1e, 0x90, 0xcf, 0x57, 0xa8, 0x47, 0xf8, 0x46, 0xee, 0x1f, 0xbe, 0x0b, 0x95, 0xe7, + 0xe1, 0xa0, 0x1b, 0x2a, 0x84, 0xc6, 0x87, 0x4b, 0x67, 0xf5, 0x8c, 0xdb, 0xaa, 0x47, 0xc9, 0x2a, + 0x47, 0x83, 0x56, 0xd5, 0x05, 0xb1, 0x7c, 0x22, 0xb4, 0x9f, 0x48, 0x6a, 0x53, 0x70, 0xe2, 0x2f, + 0x77, 0xb1, 0xf3, 0xd2, 0xc7, 0x63, 0x70, 0xa0, 0xc6, 0x2c, 0xf9, 0x09, 0x80, 0x72, 0xca, 0x19, + 0x2c, 0x65, 0x26, 0x4f, 0xbd, 0x3a, 0x4a, 0xb9, 0x7f, 0x4e, 0x32, 0x9b, 0xaf, 0x00, 0x9c, 0xd8, + 0xeb, 0x4c, 0x5d, 0xcb, 0xd3, 0xdd, 0x83, 0xa8, 0xdc, 0xfc, 0x47, 0x62, 0xe2, 0xea, 0x0d, 0x80, + 0xd3, 0x59, 0x3b, 0x7e, 0x63, 0xbf, 0x09, 0x52, 0xc8, 0x4a, 0xf5, 0x00, 0xe4, 0xc4, 0xe1, 0x23, + 0x00, 0xc7, 0x7a, 0x77, 0xad, 0x98, 0x27, 0xdd, 0x43, 0x51, 0xae, 0xf7, 0x4d, 0x49, 0x3c, 0x78, + 0xf0, 0x78, 0xd7, 0x02, 0x5c, 0xcc, 0x93, 0xea, 0x44, 0x2b, 0x57, 0xfa, 0x41, 0xc7, 0x39, 0x2b, + 0x77, 0xde, 0xb6, 0x55, 0xb0, 0xd5, 0x56, 0xc1, 0x76, 0x5b, 0x05, 0x3f, 0xdb, 0x2a, 0x78, 0xb9, + 0xa3, 0x4a, 0xdb, 0x3b, 0xaa, 0xf4, 0x6d, 0x47, 0x95, 0x1e, 0x14, 0x33, 0x0f, 0xc7, 0x7a, 0xf7, + 0x67, 0x42, 0x78, 0x47, 0x1a, 0x83, 0xe1, 0x87, 0xc1, 0xe5, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, + 0xf9, 0xb3, 0x17, 0x49, 0xf7, 0x08, 0x00, 0x00, } func (this *MsgSetWithdrawAddressResponse) Equal(that interface{}) bool { @@ -515,6 +622,54 @@ func (this *MsgFundCommunityPoolResponse) Equal(that interface{}) bool { } return true } +func (this *MsgUpdateParams) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*MsgUpdateParams) + if !ok { + that2, ok := that.(MsgUpdateParams) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if this.Authority != that1.Authority { + return false + } + if !this.Params.Equal(&that1.Params) { + return false + } + return true +} +func (this *MsgUpdateParamsResponse) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*MsgUpdateParamsResponse) + if !ok { + that2, ok := that.(MsgUpdateParamsResponse) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + return true +} // Reference imports to suppress errors if they are not otherwise used. var _ context.Context @@ -540,6 +695,11 @@ type MsgClient interface { // FundCommunityPool defines a method to allow an account to directly // fund the community pool. FundCommunityPool(ctx context.Context, in *MsgFundCommunityPool, opts ...grpc.CallOption) (*MsgFundCommunityPoolResponse, error) + // UpdateParams defines a governance operation for updating the x/distribution module + // parameters. The authority is defined in the keeper. + // + // Since: cosmos-sdk 0.47 + UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) } type msgClient struct { @@ -586,6 +746,15 @@ func (c *msgClient) FundCommunityPool(ctx context.Context, in *MsgFundCommunityP return out, nil } +func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) { + out := new(MsgUpdateParamsResponse) + err := c.cc.Invoke(ctx, "/cosmos.distribution.v1beta1.Msg/UpdateParams", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // MsgServer is the server API for Msg service. type MsgServer interface { // SetWithdrawAddress defines a method to change the withdraw address @@ -600,6 +769,11 @@ type MsgServer interface { // FundCommunityPool defines a method to allow an account to directly // fund the community pool. FundCommunityPool(context.Context, *MsgFundCommunityPool) (*MsgFundCommunityPoolResponse, error) + // UpdateParams defines a governance operation for updating the x/distribution module + // parameters. The authority is defined in the keeper. + // + // Since: cosmos-sdk 0.47 + UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error) } // UnimplementedMsgServer can be embedded to have forward compatible implementations. @@ -618,6 +792,9 @@ func (*UnimplementedMsgServer) WithdrawValidatorCommission(ctx context.Context, func (*UnimplementedMsgServer) FundCommunityPool(ctx context.Context, req *MsgFundCommunityPool) (*MsgFundCommunityPoolResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method FundCommunityPool not implemented") } +func (*UnimplementedMsgServer) UpdateParams(ctx context.Context, req *MsgUpdateParams) (*MsgUpdateParamsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateParams not implemented") +} func RegisterMsgServer(s grpc1.Server, srv MsgServer) { s.RegisterService(&_Msg_serviceDesc, srv) @@ -695,6 +872,24 @@ func _Msg_FundCommunityPool_Handler(srv interface{}, ctx context.Context, dec fu return interceptor(ctx, in, info, handler) } +func _Msg_UpdateParams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgUpdateParams) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).UpdateParams(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmos.distribution.v1beta1.Msg/UpdateParams", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).UpdateParams(ctx, req.(*MsgUpdateParams)) + } + return interceptor(ctx, in, info, handler) +} + var _Msg_serviceDesc = grpc.ServiceDesc{ ServiceName: "cosmos.distribution.v1beta1.Msg", HandlerType: (*MsgServer)(nil), @@ -715,6 +910,10 @@ var _Msg_serviceDesc = grpc.ServiceDesc{ MethodName: "FundCommunityPool", Handler: _Msg_FundCommunityPool_Handler, }, + { + MethodName: "UpdateParams", + Handler: _Msg_UpdateParams_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "cosmos/distribution/v1beta1/tx.proto", @@ -988,6 +1187,69 @@ func (m *MsgFundCommunityPoolResponse) MarshalToSizedBuffer(dAtA []byte) (int, e return len(dAtA) - i, nil } +func (m *MsgUpdateParams) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgUpdateParams) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgUpdateParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Params.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + if len(m.Authority) > 0 { + i -= len(m.Authority) + copy(dAtA[i:], m.Authority) + i = encodeVarintTx(dAtA, i, uint64(len(m.Authority))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgUpdateParamsResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgUpdateParamsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgUpdateParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + func encodeVarintTx(dAtA []byte, offset int, v uint64) int { offset -= sovTx(v) base := offset @@ -1113,6 +1375,30 @@ func (m *MsgFundCommunityPoolResponse) Size() (n int) { return n } +func (m *MsgUpdateParams) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Authority) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = m.Params.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgUpdateParamsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + func sovTx(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } @@ -1813,6 +2099,171 @@ func (m *MsgFundCommunityPoolResponse) Unmarshal(dAtA []byte) error { } return nil } +func (m *MsgUpdateParams) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgUpdateParams: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgUpdateParams: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Authority = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgUpdateParamsResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgUpdateParamsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgUpdateParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipTx(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 From 411c272d01df89cdf67c34afbba8d4188ab99320 Mon Sep 17 00:00:00 2001 From: Facundo Medica <14063057+facundomedica@users.noreply.github.com> Date: Fri, 8 Jul 2022 12:53:08 -0300 Subject: [PATCH 14/37] refactor: Use mocks for x/mint testing (#12468) ## Description Ref: https://github.com/cosmos/cosmos-sdk/issues/12398 --- ### Author Checklist *All items are required. Please add a note to the item if the item is not applicable and please add links to any relevant follow up issues.* I have... - [x] included the correct [type prefix](https://github.com/commitizen/conventional-commit-types/blob/v3.0.0/index.json) in the PR title - [x] added `!` to the type prefix if API or client breaking change - [x] targeted the correct branch (see [PR Targeting](https://github.com/cosmos/cosmos-sdk/blob/main/CONTRIBUTING.md#pr-targeting)) - [x] provided a link to the relevant issue or specification - [ ] followed the guidelines for [building modules](https://github.com/cosmos/cosmos-sdk/blob/main/docs/building-modules) - [ ] included the necessary unit and integration [tests](https://github.com/cosmos/cosmos-sdk/blob/main/CONTRIBUTING.md#testing) - [ ] added a changelog entry to `CHANGELOG.md` - [ ] included comments for [documenting Go code](https://blog.golang.org/godoc) - [ ] updated the relevant documentation or specification - [ ] reviewed "Files changed" and left comments if necessary - [ ] confirmed all CI checks have passed ### Reviewers Checklist *All items are required. Please add a note if the item is not applicable and please add your handle next to the items reviewed if you only reviewed selected items.* I have... - [ ] confirmed the correct [type prefix](https://github.com/commitizen/conventional-commit-types/blob/v3.0.0/index.json) in the PR title - [ ] confirmed `!` in the type prefix if API or client breaking change - [ ] confirmed all author checklist items have been addressed - [ ] reviewed state machine logic - [ ] reviewed API design and naming - [ ] reviewed documentation is accurate - [ ] reviewed tests and test coverage - [ ] manually tested (if applicable) --- scripts/mockgen.sh | 3 +- x/mint/keeper/grpc_query_test.go | 43 +++-- x/mint/keeper/keeper_test.go | 54 ++++-- x/mint/keeper/msg_server_test.go | 4 +- x/mint/keeper/querier_test.go | 40 +++-- x/mint/simulation/decoder_test.go | 13 +- x/mint/simulation/genesis_test.go | 14 +- x/mint/testutil/app.yaml | 47 ------ x/mint/testutil/app_config.go | 100 ++++++++++- x/mint/testutil/expected_keepers_mocks.go | 193 ++++++++++++++++++++++ 10 files changed, 402 insertions(+), 109 deletions(-) delete mode 100644 x/mint/testutil/app.yaml create mode 100644 x/mint/testutil/expected_keepers_mocks.go diff --git a/scripts/mockgen.sh b/scripts/mockgen.sh index 3894393a801c..b5b2fa7a9d98 100755 --- a/scripts/mockgen.sh +++ b/scripts/mockgen.sh @@ -11,4 +11,5 @@ $mockgen_cmd -package mocks -destination tests/mocks/grpc_server.go github.com/g $mockgen_cmd -package mocks -destination tests/mocks/tendermint_tendermint_libs_log_DB.go github.com/tendermint/tendermint/libs/log Logger $mockgen_cmd -source=orm/model/ormtable/hooks.go -package ormmocks -destination orm/testing/ormmocks/hooks.go $mockgen_cmd -source=x/nft/expected_keepers.go -package testutil -destination x/nft/testutil/expected_keepers_mocks.go -$mockgen_cmd -source=x/params/proposal_handler_test.go -package testutil -destination x/params/testutil/staking_keeper_mock.go \ No newline at end of file +$mockgen_cmd -source=x/mint/types/expected_keepers.go -package testutil -destination x/mint/testutil/expected_keepers_mocks.go +$mockgen_cmd -source=x/params/proposal_handler_test.go -package testutil -destination x/params/testutil/staking_keeper_mock.go diff --git a/x/mint/keeper/grpc_query_test.go b/x/mint/keeper/grpc_query_test.go index 71af9a07105c..34c7751f3099 100644 --- a/x/mint/keeper/grpc_query_test.go +++ b/x/mint/keeper/grpc_query_test.go @@ -4,15 +4,18 @@ import ( gocontext "context" "testing" + "github.com/golang/mock/gomock" "github.com/stretchr/testify/suite" - tmproto "github.com/tendermint/tendermint/proto/tendermint/types" "github.com/cosmos/cosmos-sdk/baseapp" - codectypes "github.com/cosmos/cosmos-sdk/codec/types" - simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims" + "github.com/cosmos/cosmos-sdk/testutil" sdk "github.com/cosmos/cosmos-sdk/types" + moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil" + authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" + govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" + "github.com/cosmos/cosmos-sdk/x/mint" "github.com/cosmos/cosmos-sdk/x/mint/keeper" - "github.com/cosmos/cosmos-sdk/x/mint/testutil" + minttestutil "github.com/cosmos/cosmos-sdk/x/mint/testutil" "github.com/cosmos/cosmos-sdk/x/mint/types" ) @@ -25,20 +28,36 @@ type MintTestSuite struct { } func (suite *MintTestSuite) SetupTest() { - var interfaceRegistry codectypes.InterfaceRegistry + encCfg := moduletestutil.MakeTestEncodingConfig(mint.AppModuleBasic{}) + key := sdk.NewKVStoreKey(types.StoreKey) + testCtx := testutil.DefaultContextWithDB(suite.T(), key, sdk.NewTransientStoreKey("transient_test")) + suite.ctx = testCtx.Ctx - app, err := simtestutil.Setup(testutil.AppConfig, - &interfaceRegistry, - &suite.mintKeeper, + // gomock initializations + ctrl := gomock.NewController(suite.T()) + accountKeeper := minttestutil.NewMockAccountKeeper(ctrl) + bankKeeper := minttestutil.NewMockBankKeeper(ctrl) + stakingKeeper := minttestutil.NewMockStakingKeeper(ctrl) + + accountKeeper.EXPECT().GetModuleAddress("mint").Return(sdk.AccAddress{}) + + suite.mintKeeper = keeper.NewKeeper( + encCfg.Codec, + key, + stakingKeeper, + accountKeeper, + bankKeeper, + authtypes.FeeCollectorName, + authtypes.NewModuleAddress(govtypes.ModuleName).String(), ) - suite.Require().NoError(err) - ctx := app.BaseApp.NewContext(false, tmproto.Header{}) + err := suite.mintKeeper.SetParams(suite.ctx, types.DefaultParams()) + suite.Require().NoError(err) + suite.mintKeeper.SetMinter(suite.ctx, types.DefaultInitialMinter()) - queryHelper := baseapp.NewQueryServerTestHelper(ctx, interfaceRegistry) + queryHelper := baseapp.NewQueryServerTestHelper(testCtx.Ctx, encCfg.InterfaceRegistry) types.RegisterQueryServer(queryHelper, suite.mintKeeper) - suite.ctx = ctx suite.queryClient = types.NewQueryClient(queryHelper) } diff --git a/x/mint/keeper/keeper_test.go b/x/mint/keeper/keeper_test.go index 79c97ea2c34f..c99fc65798eb 100644 --- a/x/mint/keeper/keeper_test.go +++ b/x/mint/keeper/keeper_test.go @@ -2,23 +2,27 @@ package keeper_test import ( "testing" - "time" + "github.com/golang/mock/gomock" "github.com/stretchr/testify/suite" - tmproto "github.com/tendermint/tendermint/proto/tendermint/types" - "github.com/cosmos/cosmos-sdk/simapp" + "github.com/cosmos/cosmos-sdk/testutil" sdk "github.com/cosmos/cosmos-sdk/types" + moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil" + authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" + govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" + "github.com/cosmos/cosmos-sdk/x/mint" "github.com/cosmos/cosmos-sdk/x/mint/keeper" + minttestutil "github.com/cosmos/cosmos-sdk/x/mint/testutil" "github.com/cosmos/cosmos-sdk/x/mint/types" ) type IntegrationTestSuite struct { suite.Suite - app *simapp.SimApp - ctx sdk.Context - msgServer types.MsgServer + mintKeeper keeper.Keeper + ctx sdk.Context + msgServer types.MsgServer } func TestKeeperTestSuite(t *testing.T) { @@ -26,12 +30,34 @@ func TestKeeperTestSuite(t *testing.T) { } func (s *IntegrationTestSuite) SetupTest() { - app := simapp.Setup(s.T(), false) - ctx := app.BaseApp.NewContext(false, tmproto.Header{Time: time.Now()}) + encCfg := moduletestutil.MakeTestEncodingConfig(mint.AppModuleBasic{}) + key := sdk.NewKVStoreKey(types.StoreKey) + testCtx := testutil.DefaultContextWithDB(s.T(), key, sdk.NewTransientStoreKey("transient_test")) + s.ctx = testCtx.Ctx - s.app = app - s.ctx = ctx - s.msgServer = keeper.NewMsgServerImpl(s.app.MintKeeper) + // gomock initializations + ctrl := gomock.NewController(s.T()) + accountKeeper := minttestutil.NewMockAccountKeeper(ctrl) + bankKeeper := minttestutil.NewMockBankKeeper(ctrl) + stakingKeeper := minttestutil.NewMockStakingKeeper(ctrl) + + accountKeeper.EXPECT().GetModuleAddress(types.ModuleName).Return(sdk.AccAddress{}) + + s.mintKeeper = keeper.NewKeeper( + encCfg.Codec, + key, + stakingKeeper, + accountKeeper, + bankKeeper, + authtypes.FeeCollectorName, + authtypes.NewModuleAddress(govtypes.ModuleName).String(), + ) + + err := s.mintKeeper.SetParams(s.ctx, types.DefaultParams()) + s.Require().NoError(err) + s.mintKeeper.SetMinter(s.ctx, types.DefaultInitialMinter()) + + s.msgServer = keeper.NewMsgServerImpl(s.mintKeeper) } func (s *IntegrationTestSuite) TestParams() { @@ -70,8 +96,8 @@ func (s *IntegrationTestSuite) TestParams() { tc := tc s.Run(tc.name, func() { - expected := s.app.MintKeeper.GetParams(s.ctx) - err := s.app.MintKeeper.SetParams(s.ctx, tc.input) + expected := s.mintKeeper.GetParams(s.ctx) + err := s.mintKeeper.SetParams(s.ctx, tc.input) if tc.expectErr { s.Require().Error(err) } else { @@ -79,7 +105,7 @@ func (s *IntegrationTestSuite) TestParams() { s.Require().NoError(err) } - p := s.app.MintKeeper.GetParams(s.ctx) + p := s.mintKeeper.GetParams(s.ctx) s.Require().Equal(expected, p) }) } diff --git a/x/mint/keeper/msg_server_test.go b/x/mint/keeper/msg_server_test.go index 1db143fca4df..f709a030c121 100644 --- a/x/mint/keeper/msg_server_test.go +++ b/x/mint/keeper/msg_server_test.go @@ -21,7 +21,7 @@ func (s *IntegrationTestSuite) TestUpdateParams() { { name: "set invalid params", request: &types.MsgUpdateParams{ - Authority: s.app.MintKeeper.GetAuthority(), + Authority: s.mintKeeper.GetAuthority(), Params: types.Params{ MintDenom: sdk.DefaultBondDenom, InflationRateChange: sdk.NewDecWithPrec(-13, 2), @@ -36,7 +36,7 @@ func (s *IntegrationTestSuite) TestUpdateParams() { { name: "set full valid params", request: &types.MsgUpdateParams{ - Authority: s.app.MintKeeper.GetAuthority(), + Authority: s.mintKeeper.GetAuthority(), Params: types.Params{ MintDenom: sdk.DefaultBondDenom, InflationRateChange: sdk.NewDecWithPrec(8, 2), diff --git a/x/mint/keeper/querier_test.go b/x/mint/keeper/querier_test.go index f5a6cebf640d..371bc510124f 100644 --- a/x/mint/keeper/querier_test.go +++ b/x/mint/keeper/querier_test.go @@ -3,17 +3,21 @@ package keeper_test import ( "testing" + "github.com/golang/mock/gomock" "github.com/stretchr/testify/require" "github.com/stretchr/testify/suite" abci "github.com/tendermint/tendermint/abci/types" - tmproto "github.com/tendermint/tendermint/proto/tendermint/types" "github.com/cosmos/cosmos-sdk/codec" - simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims" + "github.com/cosmos/cosmos-sdk/testutil" sdk "github.com/cosmos/cosmos-sdk/types" + moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil" + authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" + govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" + "github.com/cosmos/cosmos-sdk/x/mint" "github.com/cosmos/cosmos-sdk/x/mint/keeper" keep "github.com/cosmos/cosmos-sdk/x/mint/keeper" - "github.com/cosmos/cosmos-sdk/x/mint/testutil" + minttestutil "github.com/cosmos/cosmos-sdk/x/mint/testutil" "github.com/cosmos/cosmos-sdk/x/mint/types" ) @@ -26,15 +30,31 @@ type MintKeeperTestSuite struct { } func (suite *MintKeeperTestSuite) SetupTest() { - app, err := simtestutil.Setup(testutil.AppConfig, - &suite.legacyAmino, - &suite.mintKeeper, + encCfg := moduletestutil.MakeTestEncodingConfig(mint.AppModuleBasic{}) + key := sdk.NewKVStoreKey(types.StoreKey) + testCtx := testutil.DefaultContextWithDB(suite.T(), key, sdk.NewTransientStoreKey("transient_test")) + suite.ctx = testCtx.Ctx + + // gomock initializations + ctrl := gomock.NewController(suite.T()) + accountKeeper := minttestutil.NewMockAccountKeeper(ctrl) + bankKeeper := minttestutil.NewMockBankKeeper(ctrl) + stakingKeeper := minttestutil.NewMockStakingKeeper(ctrl) + + accountKeeper.EXPECT().GetModuleAddress(types.ModuleName).Return(sdk.AccAddress{}) + + suite.mintKeeper = keeper.NewKeeper( + encCfg.Codec, + key, + stakingKeeper, + accountKeeper, + bankKeeper, + authtypes.FeeCollectorName, + authtypes.NewModuleAddress(govtypes.ModuleName).String(), ) - suite.Require().NoError(err) - - suite.ctx = app.BaseApp.NewContext(true, tmproto.Header{}) - suite.mintKeeper.SetParams(suite.ctx, types.DefaultParams()) + err := suite.mintKeeper.SetParams(suite.ctx, types.DefaultParams()) + suite.Require().NoError(err) suite.mintKeeper.SetMinter(suite.ctx, types.DefaultInitialMinter()) } diff --git a/x/mint/simulation/decoder_test.go b/x/mint/simulation/decoder_test.go index 7005b8dd9fb6..16725d433086 100644 --- a/x/mint/simulation/decoder_test.go +++ b/x/mint/simulation/decoder_test.go @@ -6,27 +6,24 @@ import ( "github.com/stretchr/testify/require" - "github.com/cosmos/cosmos-sdk/codec" - "github.com/cosmos/cosmos-sdk/depinject" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/kv" + moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil" + "github.com/cosmos/cosmos-sdk/x/mint" "github.com/cosmos/cosmos-sdk/x/mint/simulation" - "github.com/cosmos/cosmos-sdk/x/mint/testutil" "github.com/cosmos/cosmos-sdk/x/mint/types" ) func TestDecodeStore(t *testing.T) { - var cdc codec.Codec - err := depinject.Inject(testutil.AppConfig, &cdc) - require.NoError(t, err) + encCfg := moduletestutil.MakeTestEncodingConfig(mint.AppModuleBasic{}) - dec := simulation.NewDecodeStore(cdc) + dec := simulation.NewDecodeStore(encCfg.Codec) minter := types.NewMinter(sdk.OneDec(), sdk.NewDec(15)) kvPairs := kv.Pairs{ Pairs: []kv.Pair{ - {Key: types.MinterKey, Value: cdc.MustMarshal(&minter)}, + {Key: types.MinterKey, Value: encCfg.Codec.MustMarshal(&minter)}, {Key: []byte{0x99}, Value: []byte{0x99}}, }, } diff --git a/x/mint/simulation/genesis_test.go b/x/mint/simulation/genesis_test.go index 93abcff65d95..a59b6f09ccc7 100644 --- a/x/mint/simulation/genesis_test.go +++ b/x/mint/simulation/genesis_test.go @@ -8,11 +8,11 @@ import ( "github.com/stretchr/testify/require" sdkmath "cosmossdk.io/math" - "github.com/cosmos/cosmos-sdk/codec" - codectypes "github.com/cosmos/cosmos-sdk/codec/types" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/module" + moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil" simtypes "github.com/cosmos/cosmos-sdk/types/simulation" + "github.com/cosmos/cosmos-sdk/x/mint" "github.com/cosmos/cosmos-sdk/x/mint/simulation" "github.com/cosmos/cosmos-sdk/x/mint/types" ) @@ -20,15 +20,14 @@ import ( // TestRandomizedGenState tests the normal scenario of applying RandomizedGenState. // Abonormal scenarios are not tested here. func TestRandomizedGenState(t *testing.T) { - interfaceRegistry := codectypes.NewInterfaceRegistry() - cdc := codec.NewProtoCodec(interfaceRegistry) + encCfg := moduletestutil.MakeTestEncodingConfig(mint.AppModuleBasic{}) s := rand.NewSource(1) r := rand.New(s) simState := module.SimulationState{ AppParams: make(simtypes.AppParams), - Cdc: cdc, + Cdc: encCfg.Codec, Rand: r, NumBonded: 3, Accounts: simtypes.RandomAccounts(r, 3), @@ -59,8 +58,7 @@ func TestRandomizedGenState(t *testing.T) { // TestRandomizedGenState tests abnormal scenarios of applying RandomizedGenState. func TestRandomizedGenState1(t *testing.T) { - interfaceRegistry := codectypes.NewInterfaceRegistry() - cdc := codec.NewProtoCodec(interfaceRegistry) + encCfg := moduletestutil.MakeTestEncodingConfig(mint.AppModuleBasic{}) s := rand.NewSource(1) r := rand.New(s) @@ -74,7 +72,7 @@ func TestRandomizedGenState1(t *testing.T) { { // panic => reason: incomplete initialization of the simState module.SimulationState{ AppParams: make(simtypes.AppParams), - Cdc: cdc, + Cdc: encCfg.Codec, Rand: r, }, "assignment to entry in nil map"}, } diff --git a/x/mint/testutil/app.yaml b/x/mint/testutil/app.yaml deleted file mode 100644 index f81fb0f1b187..000000000000 --- a/x/mint/testutil/app.yaml +++ /dev/null @@ -1,47 +0,0 @@ -modules: - - name: runtime - config: - "@type": cosmos.app.runtime.v1alpha1.Module - - app_name: MintApp - - begin_blockers: [mint, staking, auth, bank, genutil, params] - end_blockers: [staking, auth, bank, mint, genutil, params] - init_genesis: [auth, bank, staking, mint, genutil, params] - - - name: auth - config: - "@type": cosmos.auth.module.v1.Module - bech32_prefix: cosmos - module_account_permissions: - - account: fee_collector - - account: mint - permissions: [minter] - - account: bonded_tokens_pool - permissions: [burner, staking] - - account: not_bonded_tokens_pool - permissions: [burner, staking] - - - name: bank - config: - "@type": cosmos.bank.module.v1.Module - - - name: params - config: - "@type": cosmos.params.module.v1.Module - - - name: tx - config: - "@type": cosmos.tx.module.v1.Module - - - name: staking - config: - "@type": cosmos.staking.module.v1.Module - - - name: genutil - config: - "@type": cosmos.genutil.module.v1.Module - - - name: mint - config: - "@type": cosmos.mint.module.v1.Module diff --git a/x/mint/testutil/app_config.go b/x/mint/testutil/app_config.go index 5e01e53cb496..5feaa9e2188e 100644 --- a/x/mint/testutil/app_config.go +++ b/x/mint/testutil/app_config.go @@ -1,19 +1,105 @@ package testutil import ( - _ "embed" - "cosmossdk.io/core/appconfig" _ "github.com/cosmos/cosmos-sdk/x/auth" _ "github.com/cosmos/cosmos-sdk/x/auth/tx/module" _ "github.com/cosmos/cosmos-sdk/x/bank" _ "github.com/cosmos/cosmos-sdk/x/genutil" - _ "github.com/cosmos/cosmos-sdk/x/mint" _ "github.com/cosmos/cosmos-sdk/x/params" _ "github.com/cosmos/cosmos-sdk/x/staking" -) -//go:embed app.yaml -var appConfig []byte + authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" + banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" + genutiltypes "github.com/cosmos/cosmos-sdk/x/genutil/types" + minttypes "github.com/cosmos/cosmos-sdk/x/mint/types" + paramstypes "github.com/cosmos/cosmos-sdk/x/params/types" + stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" + + runtimev1alpha1 "cosmossdk.io/api/cosmos/app/runtime/v1alpha1" + appv1alpha1 "cosmossdk.io/api/cosmos/app/v1alpha1" + authmodulev1 "cosmossdk.io/api/cosmos/auth/module/v1" + bankmodulev1 "cosmossdk.io/api/cosmos/bank/module/v1" + genutilmodulev1 "cosmossdk.io/api/cosmos/genutil/module/v1" + mintmodulev1 "cosmossdk.io/api/cosmos/mint/module/v1" + paramsmodulev1 "cosmossdk.io/api/cosmos/params/module/v1" + stakingmodulev1 "cosmossdk.io/api/cosmos/staking/module/v1" + txmodulev1 "cosmossdk.io/api/cosmos/tx/module/v1" +) -var AppConfig = appconfig.LoadYAML(appConfig) +var AppConfig = appconfig.Compose(&appv1alpha1.Config{ + Modules: []*appv1alpha1.ModuleConfig{ + { + Name: "runtime", + Config: appconfig.WrapAny(&runtimev1alpha1.Module{ + AppName: "MintApp", + BeginBlockers: []string{ + minttypes.ModuleName, + stakingtypes.ModuleName, + authtypes.ModuleName, + banktypes.ModuleName, + genutiltypes.ModuleName, + paramstypes.ModuleName, + }, + EndBlockers: []string{ + stakingtypes.ModuleName, + authtypes.ModuleName, + banktypes.ModuleName, + minttypes.ModuleName, + genutiltypes.ModuleName, + paramstypes.ModuleName, + }, + OverrideStoreKeys: []*runtimev1alpha1.StoreKeyConfig{ + { + ModuleName: authtypes.ModuleName, + KvStoreKey: "acc", + }, + }, + InitGenesis: []string{ + authtypes.ModuleName, + banktypes.ModuleName, + stakingtypes.ModuleName, + minttypes.ModuleName, + genutiltypes.ModuleName, + paramstypes.ModuleName, + }, + }), + }, + { + Name: authtypes.ModuleName, + Config: appconfig.WrapAny(&authmodulev1.Module{ + Bech32Prefix: "cosmos", + ModuleAccountPermissions: []*authmodulev1.ModuleAccountPermission{ + {Account: authtypes.FeeCollectorName}, + {Account: minttypes.ModuleName, Permissions: []string{authtypes.Minter}}, + {Account: stakingtypes.BondedPoolName, Permissions: []string{authtypes.Burner, stakingtypes.ModuleName}}, + {Account: stakingtypes.NotBondedPoolName, Permissions: []string{authtypes.Burner, stakingtypes.ModuleName}}, + }, + }), + }, + { + Name: banktypes.ModuleName, + Config: appconfig.WrapAny(&bankmodulev1.Module{}), + }, + { + Name: stakingtypes.ModuleName, + Config: appconfig.WrapAny(&stakingmodulev1.Module{}), + }, + { + Name: paramstypes.ModuleName, + Config: appconfig.WrapAny(¶msmodulev1.Module{}), + }, + { + Name: "tx", + Config: appconfig.WrapAny(&txmodulev1.Module{}), + }, + { + Name: genutiltypes.ModuleName, + Config: appconfig.WrapAny(&genutilmodulev1.Module{}), + }, + { + Name: minttypes.ModuleName, + Config: appconfig.WrapAny(&mintmodulev1.Module{}), + }, + }, +}) diff --git a/x/mint/testutil/expected_keepers_mocks.go b/x/mint/testutil/expected_keepers_mocks.go new file mode 100644 index 000000000000..c174f75d97cb --- /dev/null +++ b/x/mint/testutil/expected_keepers_mocks.go @@ -0,0 +1,193 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: x/mint/types/expected_keepers.go + +// Package testutil is a generated GoMock package. +package testutil + +import ( + reflect "reflect" + + math "cosmossdk.io/math" + types "github.com/cosmos/cosmos-sdk/types" + types0 "github.com/cosmos/cosmos-sdk/x/auth/types" + gomock "github.com/golang/mock/gomock" +) + +// MockStakingKeeper is a mock of StakingKeeper interface. +type MockStakingKeeper struct { + ctrl *gomock.Controller + recorder *MockStakingKeeperMockRecorder +} + +// MockStakingKeeperMockRecorder is the mock recorder for MockStakingKeeper. +type MockStakingKeeperMockRecorder struct { + mock *MockStakingKeeper +} + +// NewMockStakingKeeper creates a new mock instance. +func NewMockStakingKeeper(ctrl *gomock.Controller) *MockStakingKeeper { + mock := &MockStakingKeeper{ctrl: ctrl} + mock.recorder = &MockStakingKeeperMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockStakingKeeper) EXPECT() *MockStakingKeeperMockRecorder { + return m.recorder +} + +// BondedRatio mocks base method. +func (m *MockStakingKeeper) BondedRatio(ctx types.Context) types.Dec { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BondedRatio", ctx) + ret0, _ := ret[0].(types.Dec) + return ret0 +} + +// BondedRatio indicates an expected call of BondedRatio. +func (mr *MockStakingKeeperMockRecorder) BondedRatio(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BondedRatio", reflect.TypeOf((*MockStakingKeeper)(nil).BondedRatio), ctx) +} + +// StakingTokenSupply mocks base method. +func (m *MockStakingKeeper) StakingTokenSupply(ctx types.Context) math.Int { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StakingTokenSupply", ctx) + ret0, _ := ret[0].(math.Int) + return ret0 +} + +// StakingTokenSupply indicates an expected call of StakingTokenSupply. +func (mr *MockStakingKeeperMockRecorder) StakingTokenSupply(ctx interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StakingTokenSupply", reflect.TypeOf((*MockStakingKeeper)(nil).StakingTokenSupply), ctx) +} + +// MockAccountKeeper is a mock of AccountKeeper interface. +type MockAccountKeeper struct { + ctrl *gomock.Controller + recorder *MockAccountKeeperMockRecorder +} + +// MockAccountKeeperMockRecorder is the mock recorder for MockAccountKeeper. +type MockAccountKeeperMockRecorder struct { + mock *MockAccountKeeper +} + +// NewMockAccountKeeper creates a new mock instance. +func NewMockAccountKeeper(ctrl *gomock.Controller) *MockAccountKeeper { + mock := &MockAccountKeeper{ctrl: ctrl} + mock.recorder = &MockAccountKeeperMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockAccountKeeper) EXPECT() *MockAccountKeeperMockRecorder { + return m.recorder +} + +// GetModuleAccount mocks base method. +func (m *MockAccountKeeper) GetModuleAccount(ctx types.Context, moduleName string) types0.ModuleAccountI { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetModuleAccount", ctx, moduleName) + ret0, _ := ret[0].(types0.ModuleAccountI) + return ret0 +} + +// GetModuleAccount indicates an expected call of GetModuleAccount. +func (mr *MockAccountKeeperMockRecorder) GetModuleAccount(ctx, moduleName interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetModuleAccount", reflect.TypeOf((*MockAccountKeeper)(nil).GetModuleAccount), ctx, moduleName) +} + +// GetModuleAddress mocks base method. +func (m *MockAccountKeeper) GetModuleAddress(name string) types.AccAddress { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetModuleAddress", name) + ret0, _ := ret[0].(types.AccAddress) + return ret0 +} + +// GetModuleAddress indicates an expected call of GetModuleAddress. +func (mr *MockAccountKeeperMockRecorder) GetModuleAddress(name interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetModuleAddress", reflect.TypeOf((*MockAccountKeeper)(nil).GetModuleAddress), name) +} + +// SetModuleAccount mocks base method. +func (m *MockAccountKeeper) SetModuleAccount(arg0 types.Context, arg1 types0.ModuleAccountI) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "SetModuleAccount", arg0, arg1) +} + +// SetModuleAccount indicates an expected call of SetModuleAccount. +func (mr *MockAccountKeeperMockRecorder) SetModuleAccount(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetModuleAccount", reflect.TypeOf((*MockAccountKeeper)(nil).SetModuleAccount), arg0, arg1) +} + +// MockBankKeeper is a mock of BankKeeper interface. +type MockBankKeeper struct { + ctrl *gomock.Controller + recorder *MockBankKeeperMockRecorder +} + +// MockBankKeeperMockRecorder is the mock recorder for MockBankKeeper. +type MockBankKeeperMockRecorder struct { + mock *MockBankKeeper +} + +// NewMockBankKeeper creates a new mock instance. +func NewMockBankKeeper(ctrl *gomock.Controller) *MockBankKeeper { + mock := &MockBankKeeper{ctrl: ctrl} + mock.recorder = &MockBankKeeperMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockBankKeeper) EXPECT() *MockBankKeeperMockRecorder { + return m.recorder +} + +// MintCoins mocks base method. +func (m *MockBankKeeper) MintCoins(ctx types.Context, name string, amt types.Coins) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "MintCoins", ctx, name, amt) + ret0, _ := ret[0].(error) + return ret0 +} + +// MintCoins indicates an expected call of MintCoins. +func (mr *MockBankKeeperMockRecorder) MintCoins(ctx, name, amt interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MintCoins", reflect.TypeOf((*MockBankKeeper)(nil).MintCoins), ctx, name, amt) +} + +// SendCoinsFromModuleToAccount mocks base method. +func (m *MockBankKeeper) SendCoinsFromModuleToAccount(ctx types.Context, senderModule string, recipientAddr types.AccAddress, amt types.Coins) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SendCoinsFromModuleToAccount", ctx, senderModule, recipientAddr, amt) + ret0, _ := ret[0].(error) + return ret0 +} + +// SendCoinsFromModuleToAccount indicates an expected call of SendCoinsFromModuleToAccount. +func (mr *MockBankKeeperMockRecorder) SendCoinsFromModuleToAccount(ctx, senderModule, recipientAddr, amt interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendCoinsFromModuleToAccount", reflect.TypeOf((*MockBankKeeper)(nil).SendCoinsFromModuleToAccount), ctx, senderModule, recipientAddr, amt) +} + +// SendCoinsFromModuleToModule mocks base method. +func (m *MockBankKeeper) SendCoinsFromModuleToModule(ctx types.Context, senderModule, recipientModule string, amt types.Coins) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SendCoinsFromModuleToModule", ctx, senderModule, recipientModule, amt) + ret0, _ := ret[0].(error) + return ret0 +} + +// SendCoinsFromModuleToModule indicates an expected call of SendCoinsFromModuleToModule. +func (mr *MockBankKeeperMockRecorder) SendCoinsFromModuleToModule(ctx, senderModule, recipientModule, amt interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendCoinsFromModuleToModule", reflect.TypeOf((*MockBankKeeper)(nil).SendCoinsFromModuleToModule), ctx, senderModule, recipientModule, amt) +} From 52bc0c16d348e6b684d63eb5e0530bba656f636d Mon Sep 17 00:00:00 2001 From: Julien Robert Date: Sat, 9 Jul 2022 17:46:07 +0200 Subject: [PATCH 15/37] refactor: rename depinject imports to cosmossdk.io/depinject (#12479) --- core/appconfig/config.go | 2 +- core/appconfig/config_test.go | 2 +- core/appmodule/option.go | 2 +- core/go.mod | 4 +- core/internal/registry.go | 2 +- core/internal/testpb/modules.go | 2 +- depinject/binding_test.go | 4 +- depinject/config.go | 8 +- depinject/container.go | 2 +- depinject/container_test.go | 2 +- depinject/debug.go | 2 +- depinject/go.mod | 2 +- depinject/group.go | 2 +- depinject/internal/graphviz/attrs.go | 2 +- depinject/internal/graphviz/graph.go | 2 +- depinject/invoke_test.go | 2 +- depinject/module_dep.go | 2 +- depinject/one_per_module.go | 2 +- depinject/provider_desc_test.go | 2 +- depinject/resolver.go | 2 +- depinject/simple.go | 2 +- depinject/supply.go | 2 +- depinject/testdata/example.dot | 56 ++--- depinject/testdata/example.svg | 254 +++++++++++----------- depinject/testdata/example_error.dot | 50 ++--- depinject/testdata/example_error.svg | 230 ++++++++++---------- go.mod | 4 +- runtime/module.go | 2 +- simapp/app.go | 2 +- simapp/test_helpers.go | 2 +- testutil/network/network.go | 2 +- testutil/sims/app_helpers.go | 2 +- x/auth/client/cli/encode_test.go | 2 +- x/auth/client/testutil/suite.go | 2 +- x/auth/client/tx_test.go | 2 +- x/auth/module.go | 2 +- x/auth/simulation/decoder_test.go | 2 +- x/auth/tx/aux_test.go | 2 +- x/auth/tx/module/module.go | 2 +- x/auth/types/account_test.go | 2 +- x/auth/types/genesis_test.go | 2 +- x/auth/vesting/module.go | 2 +- x/authz/migrations/v046/store_test.go | 2 +- x/authz/module/module.go | 2 +- x/authz/simulation/decoder_test.go | 2 +- x/authz/simulation/genesis_test.go | 2 +- x/bank/module.go | 2 +- x/capability/module.go | 2 +- x/capability/simulation/decoder_test.go | 2 +- x/crisis/module.go | 2 +- x/distribution/module.go | 6 +- x/distribution/simulation/decoder_test.go | 2 +- x/evidence/keeper/querier_test.go | 2 +- x/evidence/module.go | 2 +- x/evidence/simulation/decoder_test.go | 2 +- x/feegrant/filtered_fee_test.go | 2 +- x/feegrant/migrations/v046/store_test.go | 2 +- x/feegrant/module/module.go | 2 +- x/feegrant/simulation/decoder_test.go | 2 +- x/genutil/module.go | 2 +- x/gov/module.go | 6 +- x/group/module/module.go | 2 +- x/group/proposal_test.go | 2 +- x/group/simulation/decoder_test.go | 2 +- x/group/simulation/genesis_test.go | 2 +- x/mint/module.go | 2 +- x/nft/module/module.go | 2 +- x/params/keeper/common_test.go | 2 +- x/params/module.go | 5 +- x/params/types/subspace_test.go | 2 +- x/slashing/module.go | 2 +- x/slashing/simulation/decoder_test.go | 2 +- x/slashing/simulation/genesis_test.go | 2 +- x/staking/module.go | 6 +- x/upgrade/abci_test.go | 2 +- x/upgrade/keeper/keeper_test.go | 2 +- x/upgrade/module.go | 3 +- 77 files changed, 377 insertions(+), 387 deletions(-) diff --git a/core/appconfig/config.go b/core/appconfig/config.go index 513c76440670..27db644ecff4 100644 --- a/core/appconfig/config.go +++ b/core/appconfig/config.go @@ -14,7 +14,7 @@ import ( appv1alpha1 "cosmossdk.io/api/cosmos/app/v1alpha1" - "github.com/cosmos/cosmos-sdk/depinject" + "cosmossdk.io/depinject" "cosmossdk.io/core/internal" ) diff --git a/core/appconfig/config_test.go b/core/appconfig/config_test.go index d241be39a814..c1af334351d6 100644 --- a/core/appconfig/config_test.go +++ b/core/appconfig/config_test.go @@ -12,7 +12,7 @@ import ( "cosmossdk.io/core/internal" "cosmossdk.io/core/internal/testpb" _ "cosmossdk.io/core/internal/testpb" - "github.com/cosmos/cosmos-sdk/depinject" + "cosmossdk.io/depinject" ) func expectContainerErrorContains(t *testing.T, option depinject.Config, contains string) { diff --git a/core/appmodule/option.go b/core/appmodule/option.go index c55201bfd37d..ee1ee6492f72 100644 --- a/core/appmodule/option.go +++ b/core/appmodule/option.go @@ -2,7 +2,7 @@ package appmodule import ( "cosmossdk.io/core/internal" - "github.com/cosmos/cosmos-sdk/depinject" + "cosmossdk.io/depinject" ) // Option is a functional option for implementing modules. diff --git a/core/go.mod b/core/go.mod index bb456cda6df5..a5e7a119f796 100644 --- a/core/go.mod +++ b/core/go.mod @@ -5,7 +5,7 @@ go 1.18 require ( cosmossdk.io/api v0.1.0-alpha8 github.com/cosmos/cosmos-proto v1.0.0-alpha7 - github.com/cosmos/cosmos-sdk/depinject v1.0.0-alpha.4 + cosmossdk.io/depinject v1.0.0-alpha.4 google.golang.org/protobuf v1.28.0 gotest.tools/v3 v3.2.0 sigs.k8s.io/yaml v1.3.0 @@ -28,5 +28,5 @@ require ( replace ( cosmossdk.io/api => ../api - github.com/cosmos/cosmos-sdk/depinject => ../depinject + cosmossdk.io/depinject => ../depinject ) diff --git a/core/internal/registry.go b/core/internal/registry.go index 49693f8e8322..beb8a5446332 100644 --- a/core/internal/registry.go +++ b/core/internal/registry.go @@ -9,7 +9,7 @@ import ( appv1alpha1 "cosmossdk.io/api/cosmos/app/v1alpha1" - "github.com/cosmos/cosmos-sdk/depinject" + "cosmossdk.io/depinject" ) // ModuleRegistry is the registry of module initializers indexed by their golang diff --git a/core/internal/testpb/modules.go b/core/internal/testpb/modules.go index 358f4b90e5ed..52e8b6bb1f56 100644 --- a/core/internal/testpb/modules.go +++ b/core/internal/testpb/modules.go @@ -6,7 +6,7 @@ import ( "sort" "cosmossdk.io/core/appmodule" - "github.com/cosmos/cosmos-sdk/depinject" + "cosmossdk.io/depinject" ) func init() { diff --git a/depinject/binding_test.go b/depinject/binding_test.go index c7dccb4fdea0..be07b9ab5265 100644 --- a/depinject/binding_test.go +++ b/depinject/binding_test.go @@ -10,7 +10,7 @@ import ( "github.com/regen-network/gocuke" "github.com/stretchr/testify/assert" - "github.com/cosmos/cosmos-sdk/depinject" + "cosmossdk.io/depinject" ) func TestBindInterface(t *testing.T) { @@ -120,7 +120,7 @@ func (s *bindingSuite) ThereIsNoError() { } func fullTypeName(typeName string) string { - return fmt.Sprintf("github.com/cosmos/cosmos-sdk/depinject_test/depinject_test.%s", typeName) + return fmt.Sprintf("cosmossdk.io/depinject_test/depinject_test.%s", typeName) } func (s *bindingSuite) ThereIsAGlobalBindingForA(preferredType string, interfaceType string) { diff --git a/depinject/config.go b/depinject/config.go index 0584c27b478a..e489e28a5a4b 100644 --- a/depinject/config.go +++ b/depinject/config.go @@ -92,8 +92,8 @@ func invoke(ctr *container, key *moduleKey, invokers []interface{}) error { // instance when an interface of type Duck is requested as an input. // // BindInterface( -// "github.com/cosmos/cosmos-sdk/depinject_test/depinject_test.Duck", -// "github.com/cosmos/cosmos-sdk/depinject_test/depinject_test.Canvasback") +// "cosmossdk.io/depinject_test/depinject_test.Duck", +// "cosmossdk.io/depinject_test/depinject_test.Canvasback") func BindInterface(inTypeName string, outTypeName string) Config { return containerConfig(func(ctr *container) error { return bindInterface(ctr, inTypeName, outTypeName, "") @@ -107,8 +107,8 @@ func BindInterface(inTypeName string, outTypeName string) Config { // // BindInterfaceInModule( // "moduleFoo", -// "github.com/cosmos/cosmos-sdk/depinject_test/depinject_test.Duck", -// "github.com/cosmos/cosmos-sdk/depinject_test/depinject_test.Canvasback") +// "cosmossdk.io/depinject_test/depinject_test.Duck", +// "cosmossdk.io/depinject_test/depinject_test.Canvasback") func BindInterfaceInModule(moduleName string, inTypeName string, outTypeName string) Config { return containerConfig(func(ctr *container) error { return bindInterface(ctr, inTypeName, outTypeName, moduleName) diff --git a/depinject/container.go b/depinject/container.go index 189405ece462..90b24f1444a2 100644 --- a/depinject/container.go +++ b/depinject/container.go @@ -7,7 +7,7 @@ import ( "github.com/pkg/errors" - "github.com/cosmos/cosmos-sdk/depinject/internal/graphviz" + "cosmossdk.io/depinject/internal/graphviz" ) type container struct { diff --git a/depinject/container_test.go b/depinject/container_test.go index c1db90d77945..16fc2ad3ecf2 100644 --- a/depinject/container_test.go +++ b/depinject/container_test.go @@ -9,7 +9,7 @@ import ( "github.com/stretchr/testify/require" "gotest.tools/v3/golden" - "github.com/cosmos/cosmos-sdk/depinject" + "cosmossdk.io/depinject" ) type KVStoreKey struct { diff --git a/depinject/debug.go b/depinject/debug.go index fc4d52c8d33f..afbacb30af48 100644 --- a/depinject/debug.go +++ b/depinject/debug.go @@ -6,7 +6,7 @@ import ( "path/filepath" "reflect" - "github.com/cosmos/cosmos-sdk/depinject/internal/graphviz" + "cosmossdk.io/depinject/internal/graphviz" ) // DebugOption is a functional option for running a container that controls diff --git a/depinject/go.mod b/depinject/go.mod index 7e738836e6c5..cb648c954858 100644 --- a/depinject/go.mod +++ b/depinject/go.mod @@ -1,4 +1,4 @@ -module github.com/cosmos/cosmos-sdk/depinject +module cosmossdk.io/depinject go 1.18 diff --git a/depinject/group.go b/depinject/group.go index 4656b1c29ba6..b2e0a22ddfcf 100644 --- a/depinject/group.go +++ b/depinject/group.go @@ -6,7 +6,7 @@ import ( "github.com/pkg/errors" - "github.com/cosmos/cosmos-sdk/depinject/internal/graphviz" + "cosmossdk.io/depinject/internal/graphviz" ) // ManyPerContainerType marks a type which automatically gets grouped together. For an ManyPerContainerType T, diff --git a/depinject/internal/graphviz/attrs.go b/depinject/internal/graphviz/attrs.go index 5cd788911c43..dab9cc038599 100644 --- a/depinject/internal/graphviz/attrs.go +++ b/depinject/internal/graphviz/attrs.go @@ -4,7 +4,7 @@ import ( "fmt" "strings" - "github.com/cosmos/cosmos-sdk/depinject/internal/util" + "cosmossdk.io/depinject/internal/util" ) // Attributes represents a graphviz attributes map. diff --git a/depinject/internal/graphviz/graph.go b/depinject/internal/graphviz/graph.go index baa1d177f4a6..dc5a702c7bd6 100644 --- a/depinject/internal/graphviz/graph.go +++ b/depinject/internal/graphviz/graph.go @@ -6,7 +6,7 @@ import ( "fmt" "io" - "github.com/cosmos/cosmos-sdk/depinject/internal/util" + "cosmossdk.io/depinject/internal/util" ) // Graph represents a graphviz digraph. diff --git a/depinject/invoke_test.go b/depinject/invoke_test.go index 5d7822d4c86f..69dec08c57f0 100644 --- a/depinject/invoke_test.go +++ b/depinject/invoke_test.go @@ -6,7 +6,7 @@ import ( "github.com/regen-network/gocuke" "gotest.tools/v3/assert" - "github.com/cosmos/cosmos-sdk/depinject" + "cosmossdk.io/depinject" ) func TestInvoke(t *testing.T) { diff --git a/depinject/module_dep.go b/depinject/module_dep.go index 643cb5563063..08cf0f81bf96 100644 --- a/depinject/module_dep.go +++ b/depinject/module_dep.go @@ -3,7 +3,7 @@ package depinject import ( "reflect" - "github.com/cosmos/cosmos-sdk/depinject/internal/graphviz" + "cosmossdk.io/depinject/internal/graphviz" ) type moduleDepProvider struct { diff --git a/depinject/one_per_module.go b/depinject/one_per_module.go index 26ce1f0c3974..28d65f21f139 100644 --- a/depinject/one_per_module.go +++ b/depinject/one_per_module.go @@ -6,7 +6,7 @@ import ( "github.com/pkg/errors" - "github.com/cosmos/cosmos-sdk/depinject/internal/graphviz" + "cosmossdk.io/depinject/internal/graphviz" ) // OnePerModuleType marks a type which diff --git a/depinject/provider_desc_test.go b/depinject/provider_desc_test.go index 26a478e70762..a768e8787623 100644 --- a/depinject/provider_desc_test.go +++ b/depinject/provider_desc_test.go @@ -4,7 +4,7 @@ import ( "reflect" "testing" - "github.com/cosmos/cosmos-sdk/depinject" + "cosmossdk.io/depinject" ) type StructIn struct { diff --git a/depinject/resolver.go b/depinject/resolver.go index 9355df3c1733..352b7bf11e8e 100644 --- a/depinject/resolver.go +++ b/depinject/resolver.go @@ -3,7 +3,7 @@ package depinject import ( "reflect" - "github.com/cosmos/cosmos-sdk/depinject/internal/graphviz" + "cosmossdk.io/depinject/internal/graphviz" ) type resolver interface { diff --git a/depinject/simple.go b/depinject/simple.go index 73c29e0bb746..9b8caff8c549 100644 --- a/depinject/simple.go +++ b/depinject/simple.go @@ -3,7 +3,7 @@ package depinject import ( "reflect" - "github.com/cosmos/cosmos-sdk/depinject/internal/graphviz" + "cosmossdk.io/depinject/internal/graphviz" ) type simpleProvider struct { diff --git a/depinject/supply.go b/depinject/supply.go index 0be0caef1920..4e3a8bf9f92d 100644 --- a/depinject/supply.go +++ b/depinject/supply.go @@ -3,7 +3,7 @@ package depinject import ( "reflect" - "github.com/cosmos/cosmos-sdk/depinject/internal/graphviz" + "cosmossdk.io/depinject/internal/graphviz" ) type supplyResolver struct { diff --git a/depinject/testdata/example.dot b/depinject/testdata/example.dot index 317ecd78ffcb..ea61e3559e4d 100644 --- a/depinject/testdata/example.dot +++ b/depinject/testdata/example.dot @@ -1,43 +1,43 @@ digraph "" { subgraph "cluster_a" { graph [fontsize="12.0", label="Module: a", penwidth="0.5", style="rounded"]; - "github.com/cosmos/cosmos-sdk/depinject_test.ModuleA.Provide"[color="lightgrey", fontcolor="dimgrey", penwidth="0.5", shape="box"]; + "cosmossdk.io/depinject_test.ModuleA.Provide"[color="lightgrey", fontcolor="dimgrey", penwidth="0.5", shape="box"]; } subgraph "cluster_b" { graph [fontsize="12.0", label="Module: b", penwidth="0.5", style="rounded"]; - "github.com/cosmos/cosmos-sdk/depinject_test.ModuleB.Provide"[color="black", fontcolor="black", penwidth="1.5", shape="box"]; + "cosmossdk.io/depinject_test.ModuleB.Provide"[color="black", fontcolor="black", penwidth="1.5", shape="box"]; } subgraph "cluster_runtime" { graph [fontsize="12.0", label="Module: runtime", penwidth="0.5", style="rounded"]; - "github.com/cosmos/cosmos-sdk/depinject_test.ProvideKVStoreKey"[color="black", fontcolor="black", penwidth="1.5", shape="box"]; + "cosmossdk.io/depinject_test.ProvideKVStoreKey"[color="black", fontcolor="black", penwidth="1.5", shape="box"]; } - "[]github.com/cosmos/cosmos-sdk/depinject_test.Command"[color="lightgrey", comment="many-per-container", fontcolor="dimgrey", penwidth="0.5"]; - "github.com/cosmos/cosmos-sdk/depinject.ModuleKey"[color="black", fontcolor="black", penwidth="1.5"]; - "github.com/cosmos/cosmos-sdk/depinject.OwnModuleKey"[color="lightgrey", fontcolor="dimgrey", penwidth="0.5"]; - "github.com/cosmos/cosmos-sdk/depinject_test.KVStoreKey"[color="black", fontcolor="black", penwidth="1.5"]; - "github.com/cosmos/cosmos-sdk/depinject_test.KeeperA"[color="lightgrey", fontcolor="dimgrey", penwidth="0.5"]; - "github.com/cosmos/cosmos-sdk/depinject_test.KeeperB"[color="black", fontcolor="black", penwidth="1.5"]; - "github.com/cosmos/cosmos-sdk/depinject_test.MsgClientA"[color="black", fontcolor="black", penwidth="1.5"]; - "github.com/cosmos/cosmos-sdk/depinject_test.ProvideMsgClientA"[color="black", fontcolor="black", penwidth="1.5", shape="box"]; - "github.com/cosmos/cosmos-sdk/depinject_test.TestGraphAndLogOutput"[color="black", fontcolor="black", penwidth="1.5", shape="hexagon"]; - "map[string]github.com/cosmos/cosmos-sdk/depinject_test.Handler"[color="lightgrey", comment="one-per-module", fontcolor="dimgrey", penwidth="0.5"]; - "github.com/cosmos/cosmos-sdk/depinject.ModuleKey" -> "github.com/cosmos/cosmos-sdk/depinject_test.ProvideMsgClientA"; - "github.com/cosmos/cosmos-sdk/depinject_test.ProvideMsgClientA" -> "github.com/cosmos/cosmos-sdk/depinject_test.MsgClientA"; - "github.com/cosmos/cosmos-sdk/depinject.ModuleKey" -> "github.com/cosmos/cosmos-sdk/depinject_test.ProvideKVStoreKey"; - "github.com/cosmos/cosmos-sdk/depinject_test.ProvideKVStoreKey" -> "github.com/cosmos/cosmos-sdk/depinject_test.KVStoreKey"; - "github.com/cosmos/cosmos-sdk/depinject_test.KVStoreKey" -> "github.com/cosmos/cosmos-sdk/depinject_test.ModuleA.Provide"; - "github.com/cosmos/cosmos-sdk/depinject.OwnModuleKey" -> "github.com/cosmos/cosmos-sdk/depinject_test.ModuleA.Provide"; - "github.com/cosmos/cosmos-sdk/depinject_test.ModuleA.Provide" -> "github.com/cosmos/cosmos-sdk/depinject_test.KeeperA"; - "github.com/cosmos/cosmos-sdk/depinject_test.ModuleA.Provide" -> "map[string]github.com/cosmos/cosmos-sdk/depinject_test.Handler"; - "github.com/cosmos/cosmos-sdk/depinject_test.ModuleA.Provide" -> "[]github.com/cosmos/cosmos-sdk/depinject_test.Command"; - "github.com/cosmos/cosmos-sdk/depinject_test.KVStoreKey" -> "github.com/cosmos/cosmos-sdk/depinject_test.ModuleB.Provide"; - "github.com/cosmos/cosmos-sdk/depinject_test.MsgClientA" -> "github.com/cosmos/cosmos-sdk/depinject_test.ModuleB.Provide"; - "github.com/cosmos/cosmos-sdk/depinject_test.ModuleB.Provide" -> "github.com/cosmos/cosmos-sdk/depinject_test.KeeperB"; - "github.com/cosmos/cosmos-sdk/depinject_test.ModuleB.Provide" -> "[]github.com/cosmos/cosmos-sdk/depinject_test.Command"; - "github.com/cosmos/cosmos-sdk/depinject_test.ModuleB.Provide" -> "map[string]github.com/cosmos/cosmos-sdk/depinject_test.Handler"; - "github.com/cosmos/cosmos-sdk/depinject_test.KeeperB" -> "github.com/cosmos/cosmos-sdk/depinject_test.TestGraphAndLogOutput"; + "[]cosmossdk.io/depinject_test.Command"[color="lightgrey", comment="many-per-container", fontcolor="dimgrey", penwidth="0.5"]; + "cosmossdk.io/depinject.ModuleKey"[color="black", fontcolor="black", penwidth="1.5"]; + "cosmossdk.io/depinject.OwnModuleKey"[color="lightgrey", fontcolor="dimgrey", penwidth="0.5"]; + "cosmossdk.io/depinject_test.KVStoreKey"[color="black", fontcolor="black", penwidth="1.5"]; + "cosmossdk.io/depinject_test.KeeperA"[color="lightgrey", fontcolor="dimgrey", penwidth="0.5"]; + "cosmossdk.io/depinject_test.KeeperB"[color="black", fontcolor="black", penwidth="1.5"]; + "cosmossdk.io/depinject_test.MsgClientA"[color="black", fontcolor="black", penwidth="1.5"]; + "cosmossdk.io/depinject_test.ProvideMsgClientA"[color="black", fontcolor="black", penwidth="1.5", shape="box"]; + "cosmossdk.io/depinject_test.TestGraphAndLogOutput"[color="black", fontcolor="black", penwidth="1.5", shape="hexagon"]; + "map[string]cosmossdk.io/depinject_test.Handler"[color="lightgrey", comment="one-per-module", fontcolor="dimgrey", penwidth="0.5"]; + "cosmossdk.io/depinject.ModuleKey" -> "cosmossdk.io/depinject_test.ProvideMsgClientA"; + "cosmossdk.io/depinject_test.ProvideMsgClientA" -> "cosmossdk.io/depinject_test.MsgClientA"; + "cosmossdk.io/depinject.ModuleKey" -> "cosmossdk.io/depinject_test.ProvideKVStoreKey"; + "cosmossdk.io/depinject_test.ProvideKVStoreKey" -> "cosmossdk.io/depinject_test.KVStoreKey"; + "cosmossdk.io/depinject_test.KVStoreKey" -> "cosmossdk.io/depinject_test.ModuleA.Provide"; + "cosmossdk.io/depinject.OwnModuleKey" -> "cosmossdk.io/depinject_test.ModuleA.Provide"; + "cosmossdk.io/depinject_test.ModuleA.Provide" -> "cosmossdk.io/depinject_test.KeeperA"; + "cosmossdk.io/depinject_test.ModuleA.Provide" -> "map[string]cosmossdk.io/depinject_test.Handler"; + "cosmossdk.io/depinject_test.ModuleA.Provide" -> "[]cosmossdk.io/depinject_test.Command"; + "cosmossdk.io/depinject_test.KVStoreKey" -> "cosmossdk.io/depinject_test.ModuleB.Provide"; + "cosmossdk.io/depinject_test.MsgClientA" -> "cosmossdk.io/depinject_test.ModuleB.Provide"; + "cosmossdk.io/depinject_test.ModuleB.Provide" -> "cosmossdk.io/depinject_test.KeeperB"; + "cosmossdk.io/depinject_test.ModuleB.Provide" -> "[]cosmossdk.io/depinject_test.Command"; + "cosmossdk.io/depinject_test.ModuleB.Provide" -> "map[string]cosmossdk.io/depinject_test.Handler"; + "cosmossdk.io/depinject_test.KeeperB" -> "cosmossdk.io/depinject_test.TestGraphAndLogOutput"; } diff --git a/depinject/testdata/example.svg b/depinject/testdata/example.svg index a324b637cd01..8000c3a65b8b 100644 --- a/depinject/testdata/example.svg +++ b/depinject/testdata/example.svg @@ -1,197 +1,191 @@ - - - - - - - + + + cluster_a - -Module: a + +Module: a cluster_b - -Module: b + +Module: b cluster_runtime - -Module: runtime + +Module: runtime - + -github.com/cosmos/cosmos-sdk/container_test.ModuleA.Provide - -github.com/cosmos/cosmos-sdk/container_test.ModuleA.Provide +cosmossdk.io/depinject_test.ModuleA.Provide + +cosmossdk.io/depinject_test.ModuleA.Provide - - + + -[]github.com/cosmos/cosmos-sdk/container_test.Command - -[]github.com/cosmos/cosmos-sdk/container_test.Command +[]cosmossdk.io/depinject_test.Command + +[]cosmossdk.io/depinject_test.Command - + -github.com/cosmos/cosmos-sdk/container_test.ModuleA.Provide->[]github.com/cosmos/cosmos-sdk/container_test.Command - - +cosmossdk.io/depinject_test.ModuleA.Provide->[]cosmossdk.io/depinject_test.Command + + - + -github.com/cosmos/cosmos-sdk/container_test.KeeperA - -github.com/cosmos/cosmos-sdk/container_test.KeeperA +cosmossdk.io/depinject_test.KeeperA + +cosmossdk.io/depinject_test.KeeperA - + -github.com/cosmos/cosmos-sdk/container_test.ModuleA.Provide->github.com/cosmos/cosmos-sdk/container_test.KeeperA - - +cosmossdk.io/depinject_test.ModuleA.Provide->cosmossdk.io/depinject_test.KeeperA + + - + -map[string]github.com/cosmos/cosmos-sdk/container_test.Handler - -map[string]github.com/cosmos/cosmos-sdk/container_test.Handler +map[string]cosmossdk.io/depinject_test.Handler + +map[string]cosmossdk.io/depinject_test.Handler - + -github.com/cosmos/cosmos-sdk/container_test.ModuleA.Provide->map[string]github.com/cosmos/cosmos-sdk/container_test.Handler - - +cosmossdk.io/depinject_test.ModuleA.Provide->map[string]cosmossdk.io/depinject_test.Handler + + - + -github.com/cosmos/cosmos-sdk/container_test.ModuleB.Provide - -github.com/cosmos/cosmos-sdk/container_test.ModuleB.Provide +cosmossdk.io/depinject_test.ModuleB.Provide + +cosmossdk.io/depinject_test.ModuleB.Provide - + -github.com/cosmos/cosmos-sdk/container_test.ModuleB.Provide->[]github.com/cosmos/cosmos-sdk/container_test.Command - - +cosmossdk.io/depinject_test.ModuleB.Provide->[]cosmossdk.io/depinject_test.Command + + - + -github.com/cosmos/cosmos-sdk/container_test.KeeperB - -github.com/cosmos/cosmos-sdk/container_test.KeeperB +cosmossdk.io/depinject_test.KeeperB + +cosmossdk.io/depinject_test.KeeperB - + -github.com/cosmos/cosmos-sdk/container_test.ModuleB.Provide->github.com/cosmos/cosmos-sdk/container_test.KeeperB - - +cosmossdk.io/depinject_test.ModuleB.Provide->cosmossdk.io/depinject_test.KeeperB + + - + -github.com/cosmos/cosmos-sdk/container_test.ModuleB.Provide->map[string]github.com/cosmos/cosmos-sdk/container_test.Handler - - +cosmossdk.io/depinject_test.ModuleB.Provide->map[string]cosmossdk.io/depinject_test.Handler + + - + -github.com/cosmos/cosmos-sdk/container_test.ProvideKVStoreKey - -github.com/cosmos/cosmos-sdk/container_test.ProvideKVStoreKey +cosmossdk.io/depinject_test.ProvideKVStoreKey + +cosmossdk.io/depinject_test.ProvideKVStoreKey - + -github.com/cosmos/cosmos-sdk/container_test.KVStoreKey - -github.com/cosmos/cosmos-sdk/container_test.KVStoreKey +cosmossdk.io/depinject_test.KVStoreKey + +cosmossdk.io/depinject_test.KVStoreKey - + -github.com/cosmos/cosmos-sdk/container_test.ProvideKVStoreKey->github.com/cosmos/cosmos-sdk/container_test.KVStoreKey - - +cosmossdk.io/depinject_test.ProvideKVStoreKey->cosmossdk.io/depinject_test.KVStoreKey + + - + -github.com/cosmos/cosmos-sdk/container.ModuleKey - -github.com/cosmos/cosmos-sdk/container.ModuleKey +cosmossdk.io/depinject.ModuleKey + +cosmossdk.io/depinject.ModuleKey - + -github.com/cosmos/cosmos-sdk/container.ModuleKey->github.com/cosmos/cosmos-sdk/container_test.ProvideKVStoreKey - - +cosmossdk.io/depinject.ModuleKey->cosmossdk.io/depinject_test.ProvideKVStoreKey + + - + -github.com/cosmos/cosmos-sdk/container_test.ProvideMsgClientA - -github.com/cosmos/cosmos-sdk/container_test.ProvideMsgClientA +cosmossdk.io/depinject_test.ProvideMsgClientA + +cosmossdk.io/depinject_test.ProvideMsgClientA - + -github.com/cosmos/cosmos-sdk/container.ModuleKey->github.com/cosmos/cosmos-sdk/container_test.ProvideMsgClientA - - +cosmossdk.io/depinject.ModuleKey->cosmossdk.io/depinject_test.ProvideMsgClientA + + - + -github.com/cosmos/cosmos-sdk/container.OwnModuleKey - -github.com/cosmos/cosmos-sdk/container.OwnModuleKey +cosmossdk.io/depinject.OwnModuleKey + +cosmossdk.io/depinject.OwnModuleKey - + -github.com/cosmos/cosmos-sdk/container.OwnModuleKey->github.com/cosmos/cosmos-sdk/container_test.ModuleA.Provide - - +cosmossdk.io/depinject.OwnModuleKey->cosmossdk.io/depinject_test.ModuleA.Provide + + - + -github.com/cosmos/cosmos-sdk/container_test.KVStoreKey->github.com/cosmos/cosmos-sdk/container_test.ModuleA.Provide - - +cosmossdk.io/depinject_test.KVStoreKey->cosmossdk.io/depinject_test.ModuleA.Provide + + - + -github.com/cosmos/cosmos-sdk/container_test.KVStoreKey->github.com/cosmos/cosmos-sdk/container_test.ModuleB.Provide - - +cosmossdk.io/depinject_test.KVStoreKey->cosmossdk.io/depinject_test.ModuleB.Provide + + - + -github.com/cosmos/cosmos-sdk/container_test.TestGraphAndLogOutput - -github.com/cosmos/cosmos-sdk/container_test.TestGraphAndLogOutput +cosmossdk.io/depinject_test.TestGraphAndLogOutput + +cosmossdk.io/depinject_test.TestGraphAndLogOutput - + -github.com/cosmos/cosmos-sdk/container_test.KeeperB->github.com/cosmos/cosmos-sdk/container_test.TestGraphAndLogOutput - - +cosmossdk.io/depinject_test.KeeperB->cosmossdk.io/depinject_test.TestGraphAndLogOutput + + - + -github.com/cosmos/cosmos-sdk/container_test.MsgClientA - -github.com/cosmos/cosmos-sdk/container_test.MsgClientA +cosmossdk.io/depinject_test.MsgClientA + +cosmossdk.io/depinject_test.MsgClientA - + -github.com/cosmos/cosmos-sdk/container_test.MsgClientA->github.com/cosmos/cosmos-sdk/container_test.ModuleB.Provide - - +cosmossdk.io/depinject_test.MsgClientA->cosmossdk.io/depinject_test.ModuleB.Provide + + - + -github.com/cosmos/cosmos-sdk/container_test.ProvideMsgClientA->github.com/cosmos/cosmos-sdk/container_test.MsgClientA - - +cosmossdk.io/depinject_test.ProvideMsgClientA->cosmossdk.io/depinject_test.MsgClientA + + - + \ No newline at end of file diff --git a/depinject/testdata/example_error.dot b/depinject/testdata/example_error.dot index 2d075537f5ff..a47386cdd4d2 100644 --- a/depinject/testdata/example_error.dot +++ b/depinject/testdata/example_error.dot @@ -1,40 +1,40 @@ digraph "" { subgraph "cluster_a" { graph [fontsize="12.0", label="Module: a", penwidth="0.5", style="rounded"]; - "github.com/cosmos/cosmos-sdk/depinject_test.ModuleA.Provide"[color="lightgrey", fontcolor="dimgrey", penwidth="0.5", shape="box"]; + "cosmossdk.io/depinject_test.ModuleA.Provide"[color="lightgrey", fontcolor="dimgrey", penwidth="0.5", shape="box"]; } subgraph "cluster_b" { graph [fontsize="12.0", label="Module: b", penwidth="0.5", style="rounded"]; - "github.com/cosmos/cosmos-sdk/depinject_test.ModuleB.Provide"[color="red", fontcolor="red", penwidth="0.5", shape="box"]; + "cosmossdk.io/depinject_test.ModuleB.Provide"[color="red", fontcolor="red", penwidth="0.5", shape="box"]; } subgraph "cluster_runtime" { graph [fontsize="12.0", label="Module: runtime", penwidth="0.5", style="rounded"]; - "github.com/cosmos/cosmos-sdk/depinject_test.ProvideKVStoreKey"[color="black", fontcolor="black", penwidth="1.5", shape="box"]; + "cosmossdk.io/depinject_test.ProvideKVStoreKey"[color="black", fontcolor="black", penwidth="1.5", shape="box"]; } - "[]github.com/cosmos/cosmos-sdk/depinject_test.Command"[color="lightgrey", comment="many-per-container", fontcolor="dimgrey", penwidth="0.5"]; - "github.com/cosmos/cosmos-sdk/depinject.ModuleKey"[color="black", fontcolor="black", penwidth="1.5"]; - "github.com/cosmos/cosmos-sdk/depinject.OwnModuleKey"[color="lightgrey", fontcolor="dimgrey", penwidth="0.5"]; - "github.com/cosmos/cosmos-sdk/depinject_test.KVStoreKey"[color="black", fontcolor="black", penwidth="1.5"]; - "github.com/cosmos/cosmos-sdk/depinject_test.KeeperA"[color="lightgrey", fontcolor="dimgrey", penwidth="0.5"]; - "github.com/cosmos/cosmos-sdk/depinject_test.KeeperB"[color="red", fontcolor="red", penwidth="0.5"]; - "github.com/cosmos/cosmos-sdk/depinject_test.MsgClientA"[color="red", fontcolor="red", penwidth="0.5"]; - "github.com/cosmos/cosmos-sdk/depinject_test.TestGraphAndLogOutput"[color="red", fontcolor="red", penwidth="0.5", shape="hexagon"]; - "map[string]github.com/cosmos/cosmos-sdk/depinject_test.Handler"[color="lightgrey", comment="one-per-module", fontcolor="dimgrey", penwidth="0.5"]; - "github.com/cosmos/cosmos-sdk/depinject.ModuleKey" -> "github.com/cosmos/cosmos-sdk/depinject_test.ProvideKVStoreKey"; - "github.com/cosmos/cosmos-sdk/depinject_test.ProvideKVStoreKey" -> "github.com/cosmos/cosmos-sdk/depinject_test.KVStoreKey"; - "github.com/cosmos/cosmos-sdk/depinject_test.KVStoreKey" -> "github.com/cosmos/cosmos-sdk/depinject_test.ModuleA.Provide"; - "github.com/cosmos/cosmos-sdk/depinject.OwnModuleKey" -> "github.com/cosmos/cosmos-sdk/depinject_test.ModuleA.Provide"; - "github.com/cosmos/cosmos-sdk/depinject_test.ModuleA.Provide" -> "github.com/cosmos/cosmos-sdk/depinject_test.KeeperA"; - "github.com/cosmos/cosmos-sdk/depinject_test.ModuleA.Provide" -> "map[string]github.com/cosmos/cosmos-sdk/depinject_test.Handler"; - "github.com/cosmos/cosmos-sdk/depinject_test.ModuleA.Provide" -> "[]github.com/cosmos/cosmos-sdk/depinject_test.Command"; - "github.com/cosmos/cosmos-sdk/depinject_test.KVStoreKey" -> "github.com/cosmos/cosmos-sdk/depinject_test.ModuleB.Provide"; - "github.com/cosmos/cosmos-sdk/depinject_test.MsgClientA" -> "github.com/cosmos/cosmos-sdk/depinject_test.ModuleB.Provide"; - "github.com/cosmos/cosmos-sdk/depinject_test.ModuleB.Provide" -> "github.com/cosmos/cosmos-sdk/depinject_test.KeeperB"; - "github.com/cosmos/cosmos-sdk/depinject_test.ModuleB.Provide" -> "[]github.com/cosmos/cosmos-sdk/depinject_test.Command"; - "github.com/cosmos/cosmos-sdk/depinject_test.ModuleB.Provide" -> "map[string]github.com/cosmos/cosmos-sdk/depinject_test.Handler"; - "github.com/cosmos/cosmos-sdk/depinject_test.KeeperB" -> "github.com/cosmos/cosmos-sdk/depinject_test.TestGraphAndLogOutput"; + "[]cosmossdk.io/depinject_test.Command"[color="lightgrey", comment="many-per-container", fontcolor="dimgrey", penwidth="0.5"]; + "cosmossdk.io/depinject.ModuleKey"[color="black", fontcolor="black", penwidth="1.5"]; + "cosmossdk.io/depinject.OwnModuleKey"[color="lightgrey", fontcolor="dimgrey", penwidth="0.5"]; + "cosmossdk.io/depinject_test.KVStoreKey"[color="black", fontcolor="black", penwidth="1.5"]; + "cosmossdk.io/depinject_test.KeeperA"[color="lightgrey", fontcolor="dimgrey", penwidth="0.5"]; + "cosmossdk.io/depinject_test.KeeperB"[color="red", fontcolor="red", penwidth="0.5"]; + "cosmossdk.io/depinject_test.MsgClientA"[color="red", fontcolor="red", penwidth="0.5"]; + "cosmossdk.io/depinject_test.TestGraphAndLogOutput"[color="red", fontcolor="red", penwidth="0.5", shape="hexagon"]; + "map[string]cosmossdk.io/depinject_test.Handler"[color="lightgrey", comment="one-per-module", fontcolor="dimgrey", penwidth="0.5"]; + "cosmossdk.io/depinject.ModuleKey" -> "cosmossdk.io/depinject_test.ProvideKVStoreKey"; + "cosmossdk.io/depinject_test.ProvideKVStoreKey" -> "cosmossdk.io/depinject_test.KVStoreKey"; + "cosmossdk.io/depinject_test.KVStoreKey" -> "cosmossdk.io/depinject_test.ModuleA.Provide"; + "cosmossdk.io/depinject.OwnModuleKey" -> "cosmossdk.io/depinject_test.ModuleA.Provide"; + "cosmossdk.io/depinject_test.ModuleA.Provide" -> "cosmossdk.io/depinject_test.KeeperA"; + "cosmossdk.io/depinject_test.ModuleA.Provide" -> "map[string]cosmossdk.io/depinject_test.Handler"; + "cosmossdk.io/depinject_test.ModuleA.Provide" -> "[]cosmossdk.io/depinject_test.Command"; + "cosmossdk.io/depinject_test.KVStoreKey" -> "cosmossdk.io/depinject_test.ModuleB.Provide"; + "cosmossdk.io/depinject_test.MsgClientA" -> "cosmossdk.io/depinject_test.ModuleB.Provide"; + "cosmossdk.io/depinject_test.ModuleB.Provide" -> "cosmossdk.io/depinject_test.KeeperB"; + "cosmossdk.io/depinject_test.ModuleB.Provide" -> "[]cosmossdk.io/depinject_test.Command"; + "cosmossdk.io/depinject_test.ModuleB.Provide" -> "map[string]cosmossdk.io/depinject_test.Handler"; + "cosmossdk.io/depinject_test.KeeperB" -> "cosmossdk.io/depinject_test.TestGraphAndLogOutput"; } diff --git a/depinject/testdata/example_error.svg b/depinject/testdata/example_error.svg index 6897a23dc9da..d92675a8df8c 100644 --- a/depinject/testdata/example_error.svg +++ b/depinject/testdata/example_error.svg @@ -1,179 +1,173 @@ - - - - - - - + + + cluster_a - -Module: a + +Module: a cluster_b - -Module: b + +Module: b cluster_runtime - -Module: runtime + +Module: runtime - + -github.com/cosmos/cosmos-sdk/container_test.ModuleA.Provide - -github.com/cosmos/cosmos-sdk/container_test.ModuleA.Provide +cosmossdk.io/depinject_test.ModuleA.Provide + +cosmossdk.io/depinject_test.ModuleA.Provide - - + + -[]github.com/cosmos/cosmos-sdk/container_test.Command - -[]github.com/cosmos/cosmos-sdk/container_test.Command +[]cosmossdk.io/depinject_test.Command + +[]cosmossdk.io/depinject_test.Command - + -github.com/cosmos/cosmos-sdk/container_test.ModuleA.Provide->[]github.com/cosmos/cosmos-sdk/container_test.Command - - +cosmossdk.io/depinject_test.ModuleA.Provide->[]cosmossdk.io/depinject_test.Command + + - + -github.com/cosmos/cosmos-sdk/container_test.KeeperA - -github.com/cosmos/cosmos-sdk/container_test.KeeperA +cosmossdk.io/depinject_test.KeeperA + +cosmossdk.io/depinject_test.KeeperA - + -github.com/cosmos/cosmos-sdk/container_test.ModuleA.Provide->github.com/cosmos/cosmos-sdk/container_test.KeeperA - - +cosmossdk.io/depinject_test.ModuleA.Provide->cosmossdk.io/depinject_test.KeeperA + + - + -map[string]github.com/cosmos/cosmos-sdk/container_test.Handler - -map[string]github.com/cosmos/cosmos-sdk/container_test.Handler +map[string]cosmossdk.io/depinject_test.Handler + +map[string]cosmossdk.io/depinject_test.Handler - + -github.com/cosmos/cosmos-sdk/container_test.ModuleA.Provide->map[string]github.com/cosmos/cosmos-sdk/container_test.Handler - - +cosmossdk.io/depinject_test.ModuleA.Provide->map[string]cosmossdk.io/depinject_test.Handler + + - + -github.com/cosmos/cosmos-sdk/container_test.ModuleB.Provide - -github.com/cosmos/cosmos-sdk/container_test.ModuleB.Provide +cosmossdk.io/depinject_test.ModuleB.Provide + +cosmossdk.io/depinject_test.ModuleB.Provide - + -github.com/cosmos/cosmos-sdk/container_test.ModuleB.Provide->[]github.com/cosmos/cosmos-sdk/container_test.Command - - +cosmossdk.io/depinject_test.ModuleB.Provide->[]cosmossdk.io/depinject_test.Command + + - + -github.com/cosmos/cosmos-sdk/container_test.KeeperB - -github.com/cosmos/cosmos-sdk/container_test.KeeperB +cosmossdk.io/depinject_test.KeeperB + +cosmossdk.io/depinject_test.KeeperB - + -github.com/cosmos/cosmos-sdk/container_test.ModuleB.Provide->github.com/cosmos/cosmos-sdk/container_test.KeeperB - - +cosmossdk.io/depinject_test.ModuleB.Provide->cosmossdk.io/depinject_test.KeeperB + + - + -github.com/cosmos/cosmos-sdk/container_test.ModuleB.Provide->map[string]github.com/cosmos/cosmos-sdk/container_test.Handler - - +cosmossdk.io/depinject_test.ModuleB.Provide->map[string]cosmossdk.io/depinject_test.Handler + + - + -github.com/cosmos/cosmos-sdk/container_test.ProvideKVStoreKey - -github.com/cosmos/cosmos-sdk/container_test.ProvideKVStoreKey +cosmossdk.io/depinject_test.ProvideKVStoreKey + +cosmossdk.io/depinject_test.ProvideKVStoreKey - + -github.com/cosmos/cosmos-sdk/container_test.KVStoreKey - -github.com/cosmos/cosmos-sdk/container_test.KVStoreKey +cosmossdk.io/depinject_test.KVStoreKey + +cosmossdk.io/depinject_test.KVStoreKey - + -github.com/cosmos/cosmos-sdk/container_test.ProvideKVStoreKey->github.com/cosmos/cosmos-sdk/container_test.KVStoreKey - - +cosmossdk.io/depinject_test.ProvideKVStoreKey->cosmossdk.io/depinject_test.KVStoreKey + + - + -github.com/cosmos/cosmos-sdk/container.ModuleKey - -github.com/cosmos/cosmos-sdk/container.ModuleKey +cosmossdk.io/depinject.ModuleKey + +cosmossdk.io/depinject.ModuleKey - + -github.com/cosmos/cosmos-sdk/container.ModuleKey->github.com/cosmos/cosmos-sdk/container_test.ProvideKVStoreKey - - +cosmossdk.io/depinject.ModuleKey->cosmossdk.io/depinject_test.ProvideKVStoreKey + + - + -github.com/cosmos/cosmos-sdk/container.OwnModuleKey - -github.com/cosmos/cosmos-sdk/container.OwnModuleKey +cosmossdk.io/depinject.OwnModuleKey + +cosmossdk.io/depinject.OwnModuleKey - + -github.com/cosmos/cosmos-sdk/container.OwnModuleKey->github.com/cosmos/cosmos-sdk/container_test.ModuleA.Provide - - +cosmossdk.io/depinject.OwnModuleKey->cosmossdk.io/depinject_test.ModuleA.Provide + + - + -github.com/cosmos/cosmos-sdk/container_test.KVStoreKey->github.com/cosmos/cosmos-sdk/container_test.ModuleA.Provide - - +cosmossdk.io/depinject_test.KVStoreKey->cosmossdk.io/depinject_test.ModuleA.Provide + + - + -github.com/cosmos/cosmos-sdk/container_test.KVStoreKey->github.com/cosmos/cosmos-sdk/container_test.ModuleB.Provide - - +cosmossdk.io/depinject_test.KVStoreKey->cosmossdk.io/depinject_test.ModuleB.Provide + + - + -github.com/cosmos/cosmos-sdk/container_test.TestGraphAndLogOutput - -github.com/cosmos/cosmos-sdk/container_test.TestGraphAndLogOutput +cosmossdk.io/depinject_test.TestGraphAndLogOutput + +cosmossdk.io/depinject_test.TestGraphAndLogOutput - + -github.com/cosmos/cosmos-sdk/container_test.KeeperB->github.com/cosmos/cosmos-sdk/container_test.TestGraphAndLogOutput - - +cosmossdk.io/depinject_test.KeeperB->cosmossdk.io/depinject_test.TestGraphAndLogOutput + + - + -github.com/cosmos/cosmos-sdk/container_test.MsgClientA - -github.com/cosmos/cosmos-sdk/container_test.MsgClientA +cosmossdk.io/depinject_test.MsgClientA + +cosmossdk.io/depinject_test.MsgClientA - + -github.com/cosmos/cosmos-sdk/container_test.MsgClientA->github.com/cosmos/cosmos-sdk/container_test.ModuleB.Provide - - +cosmossdk.io/depinject_test.MsgClientA->cosmossdk.io/depinject_test.ModuleB.Provide + + - + \ No newline at end of file diff --git a/go.mod b/go.mod index 290280b3a848..a8030774b1e8 100644 --- a/go.mod +++ b/go.mod @@ -17,7 +17,7 @@ require ( github.com/cosmos/btcutil v1.0.4 github.com/cosmos/cosmos-proto v1.0.0-alpha7 github.com/cosmos/cosmos-sdk/db v1.0.0-beta.1 - github.com/cosmos/cosmos-sdk/depinject v1.0.0-alpha.4 + cosmossdk.io/depinject v1.0.0-alpha.4 github.com/cosmos/cosmos-sdk/store/tools/ics23 v0.0.0-20220608170201-b0e82f964070 github.com/cosmos/go-bip39 v1.0.0 github.com/cosmos/iavl v0.18.0 @@ -280,7 +280,7 @@ replace ( cosmossdk.io/core => ./core github.com/99designs/keyring => github.com/cosmos/keyring v1.1.7-0.20210622111912-ef00f8ac3d76 github.com/cosmos/cosmos-sdk/db => ./db - github.com/cosmos/cosmos-sdk/depinject => ./depinject + cosmossdk.io/depinject => ./depinject // Fix upstream GHSA-h395-qcrw-5vmq vulnerability. // TODO Remove it: https://github.com/cosmos/cosmos-sdk/issues/10409 diff --git a/runtime/module.go b/runtime/module.go index fe598f22ee42..07ff9a430d73 100644 --- a/runtime/module.go +++ b/runtime/module.go @@ -7,10 +7,10 @@ import ( runtimev1alpha1 "cosmossdk.io/api/cosmos/app/runtime/v1alpha1" "cosmossdk.io/core/appmodule" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/baseapp" "github.com/cosmos/cosmos-sdk/codec" codectypes "github.com/cosmos/cosmos-sdk/codec/types" - "github.com/cosmos/cosmos-sdk/depinject" "github.com/cosmos/cosmos-sdk/std" storetypes "github.com/cosmos/cosmos-sdk/store/types" "github.com/cosmos/cosmos-sdk/types/module" diff --git a/simapp/app.go b/simapp/app.go index 5af2f8ad1933..5c824723688c 100644 --- a/simapp/app.go +++ b/simapp/app.go @@ -16,11 +16,11 @@ import ( tmos "github.com/tendermint/tendermint/libs/os" dbm "github.com/tendermint/tm-db" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/baseapp" "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/codec" codectypes "github.com/cosmos/cosmos-sdk/codec/types" - "github.com/cosmos/cosmos-sdk/depinject" "github.com/cosmos/cosmos-sdk/runtime" "github.com/cosmos/cosmos-sdk/server/api" "github.com/cosmos/cosmos-sdk/server/config" diff --git a/simapp/test_helpers.go b/simapp/test_helpers.go index fd6426c91d46..e3a1cf694c9b 100644 --- a/simapp/test_helpers.go +++ b/simapp/test_helpers.go @@ -15,13 +15,13 @@ import ( tmtypes "github.com/tendermint/tendermint/types" dbm "github.com/tendermint/tm-db" + "cosmossdk.io/depinject" "cosmossdk.io/math" bam "github.com/cosmos/cosmos-sdk/baseapp" "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/client/flags" "github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1" cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types" - "github.com/cosmos/cosmos-sdk/depinject" "github.com/cosmos/cosmos-sdk/server" "github.com/cosmos/cosmos-sdk/server/types" "github.com/cosmos/cosmos-sdk/simapp/params" diff --git a/testutil/network/network.go b/testutil/network/network.go index 19f2b0fc66c7..dd37d270faff 100644 --- a/testutil/network/network.go +++ b/testutil/network/network.go @@ -26,6 +26,7 @@ import ( "cosmossdk.io/math" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/baseapp" "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/client/tx" @@ -34,7 +35,6 @@ import ( "github.com/cosmos/cosmos-sdk/crypto/hd" "github.com/cosmos/cosmos-sdk/crypto/keyring" cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types" - "github.com/cosmos/cosmos-sdk/depinject" pruningtypes "github.com/cosmos/cosmos-sdk/pruning/types" "github.com/cosmos/cosmos-sdk/runtime" "github.com/cosmos/cosmos-sdk/server" diff --git a/testutil/sims/app_helpers.go b/testutil/sims/app_helpers.go index 8c6d29a04384..03d6323ebfa7 100644 --- a/testutil/sims/app_helpers.go +++ b/testutil/sims/app_helpers.go @@ -13,12 +13,12 @@ import ( tmtypes "github.com/tendermint/tendermint/types" dbm "github.com/tendermint/tm-db" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/client/flags" "github.com/cosmos/cosmos-sdk/codec" codectypes "github.com/cosmos/cosmos-sdk/codec/types" cryptocodec "github.com/cosmos/cosmos-sdk/crypto/codec" "github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1" - "github.com/cosmos/cosmos-sdk/depinject" "github.com/cosmos/cosmos-sdk/runtime" servertypes "github.com/cosmos/cosmos-sdk/server/types" "github.com/cosmos/cosmos-sdk/testutil/mock" diff --git a/x/auth/client/cli/encode_test.go b/x/auth/client/cli/encode_test.go index e74d92a35d4e..219491b2fce6 100644 --- a/x/auth/client/cli/encode_test.go +++ b/x/auth/client/cli/encode_test.go @@ -7,9 +7,9 @@ import ( "github.com/stretchr/testify/require" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/codec" - "github.com/cosmos/cosmos-sdk/depinject" "github.com/cosmos/cosmos-sdk/testutil" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/auth/client/cli" diff --git a/x/auth/client/testutil/suite.go b/x/auth/client/testutil/suite.go index 5bc6b735fc67..2508744e2cc6 100644 --- a/x/auth/client/testutil/suite.go +++ b/x/auth/client/testutil/suite.go @@ -14,8 +14,8 @@ import ( "github.com/stretchr/testify/suite" tmcli "github.com/tendermint/tendermint/libs/cli" + "cosmossdk.io/depinject" "cosmossdk.io/math" - "github.com/cosmos/cosmos-sdk/depinject" authtestutil "github.com/cosmos/cosmos-sdk/x/auth/testutil" "github.com/cosmos/cosmos-sdk/client" diff --git a/x/auth/client/tx_test.go b/x/auth/client/tx_test.go index 13de490c67df..9be7a9015646 100644 --- a/x/auth/client/tx_test.go +++ b/x/auth/client/tx_test.go @@ -7,12 +7,12 @@ import ( "github.com/stretchr/testify/require" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/codec" codectypes "github.com/cosmos/cosmos-sdk/codec/types" cryptocodec "github.com/cosmos/cosmos-sdk/crypto/codec" "github.com/cosmos/cosmos-sdk/crypto/keys/ed25519" - "github.com/cosmos/cosmos-sdk/depinject" "github.com/cosmos/cosmos-sdk/testutil" "github.com/cosmos/cosmos-sdk/testutil/testdata" sdk "github.com/cosmos/cosmos-sdk/types" diff --git a/x/auth/module.go b/x/auth/module.go index e516464f2059..8b1885aa67ac 100644 --- a/x/auth/module.go +++ b/x/auth/module.go @@ -6,7 +6,7 @@ import ( "fmt" "math/rand" - "github.com/cosmos/cosmos-sdk/depinject" + "cosmossdk.io/depinject" gwruntime "github.com/grpc-ecosystem/grpc-gateway/runtime" diff --git a/x/auth/simulation/decoder_test.go b/x/auth/simulation/decoder_test.go index 3dfb6576c880..efc7dcc461c4 100644 --- a/x/auth/simulation/decoder_test.go +++ b/x/auth/simulation/decoder_test.go @@ -7,9 +7,9 @@ import ( gogotypes "github.com/gogo/protobuf/types" "github.com/stretchr/testify/require" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/codec" "github.com/cosmos/cosmos-sdk/crypto/keys/ed25519" - "github.com/cosmos/cosmos-sdk/depinject" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/kv" "github.com/cosmos/cosmos-sdk/x/auth/simulation" diff --git a/x/auth/tx/aux_test.go b/x/auth/tx/aux_test.go index 2f86c9ec7177..023b7b477ad7 100644 --- a/x/auth/tx/aux_test.go +++ b/x/auth/tx/aux_test.go @@ -5,11 +5,11 @@ import ( "github.com/stretchr/testify/require" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/client/tx" clienttx "github.com/cosmos/cosmos-sdk/client/tx" codectypes "github.com/cosmos/cosmos-sdk/codec/types" - "github.com/cosmos/cosmos-sdk/depinject" "github.com/cosmos/cosmos-sdk/testutil/testdata" sdk "github.com/cosmos/cosmos-sdk/types" txtypes "github.com/cosmos/cosmos-sdk/types/tx" diff --git a/x/auth/tx/module/module.go b/x/auth/tx/module/module.go index a4850bfc9ae5..b005d6cadc16 100644 --- a/x/auth/tx/module/module.go +++ b/x/auth/tx/module/module.go @@ -5,10 +5,10 @@ import ( modulev1 "cosmossdk.io/api/cosmos/tx/module/v1" "cosmossdk.io/core/appmodule" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/baseapp" "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/codec" - "github.com/cosmos/cosmos-sdk/depinject" "github.com/cosmos/cosmos-sdk/runtime" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/auth/ante" diff --git a/x/auth/types/account_test.go b/x/auth/types/account_test.go index 5289f4aeeb54..20a045bbb8cb 100644 --- a/x/auth/types/account_test.go +++ b/x/auth/types/account_test.go @@ -9,8 +9,8 @@ import ( "github.com/stretchr/testify/require" "sigs.k8s.io/yaml" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1" - "github.com/cosmos/cosmos-sdk/depinject" "github.com/cosmos/cosmos-sdk/testutil/testdata" sdk "github.com/cosmos/cosmos-sdk/types" authkeeper "github.com/cosmos/cosmos-sdk/x/auth/keeper" diff --git a/x/auth/types/genesis_test.go b/x/auth/types/genesis_test.go index b6f0bce62e7a..afa41b2759b5 100644 --- a/x/auth/types/genesis_test.go +++ b/x/auth/types/genesis_test.go @@ -4,8 +4,8 @@ import ( "encoding/json" "testing" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/codec" - "github.com/cosmos/cosmos-sdk/depinject" proto "github.com/gogo/protobuf/proto" "github.com/stretchr/testify/require" diff --git a/x/auth/vesting/module.go b/x/auth/vesting/module.go index fe70dfdd1143..4484e0a34be2 100644 --- a/x/auth/vesting/module.go +++ b/x/auth/vesting/module.go @@ -7,10 +7,10 @@ import ( "github.com/spf13/cobra" abci "github.com/tendermint/tendermint/abci/types" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/codec" codectypes "github.com/cosmos/cosmos-sdk/codec/types" - "github.com/cosmos/cosmos-sdk/depinject" "github.com/cosmos/cosmos-sdk/runtime" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/module" diff --git a/x/authz/migrations/v046/store_test.go b/x/authz/migrations/v046/store_test.go index 922b21b30b36..0cefd65cf767 100644 --- a/x/authz/migrations/v046/store_test.go +++ b/x/authz/migrations/v046/store_test.go @@ -4,10 +4,10 @@ import ( "testing" "time" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/codec" codectypes "github.com/cosmos/cosmos-sdk/codec/types" "github.com/cosmos/cosmos-sdk/crypto/keys/ed25519" - "github.com/cosmos/cosmos-sdk/depinject" "github.com/cosmos/cosmos-sdk/testutil" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/authz" diff --git a/x/authz/module/module.go b/x/authz/module/module.go index 0ee9a8a2ddc9..6f1e2431bde2 100644 --- a/x/authz/module/module.go +++ b/x/authz/module/module.go @@ -12,11 +12,11 @@ import ( modulev1 "cosmossdk.io/api/cosmos/authz/module/v1" "cosmossdk.io/core/appmodule" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/baseapp" sdkclient "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/codec" cdctypes "github.com/cosmos/cosmos-sdk/codec/types" - "github.com/cosmos/cosmos-sdk/depinject" "github.com/cosmos/cosmos-sdk/runtime" store "github.com/cosmos/cosmos-sdk/store/types" sdk "github.com/cosmos/cosmos-sdk/types" diff --git a/x/authz/simulation/decoder_test.go b/x/authz/simulation/decoder_test.go index e212a860a179..a5737ace5ee3 100644 --- a/x/authz/simulation/decoder_test.go +++ b/x/authz/simulation/decoder_test.go @@ -7,8 +7,8 @@ import ( "github.com/stretchr/testify/require" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/codec" - "github.com/cosmos/cosmos-sdk/depinject" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/kv" "github.com/cosmos/cosmos-sdk/x/authz" diff --git a/x/authz/simulation/genesis_test.go b/x/authz/simulation/genesis_test.go index 272186197214..a6ad0e399530 100644 --- a/x/authz/simulation/genesis_test.go +++ b/x/authz/simulation/genesis_test.go @@ -7,9 +7,9 @@ import ( "github.com/stretchr/testify/require" + "cosmossdk.io/depinject" sdkmath "cosmossdk.io/math" "github.com/cosmos/cosmos-sdk/codec" - "github.com/cosmos/cosmos-sdk/depinject" "github.com/cosmos/cosmos-sdk/types/module" simtypes "github.com/cosmos/cosmos-sdk/types/simulation" "github.com/cosmos/cosmos-sdk/x/authz" diff --git a/x/bank/module.go b/x/bank/module.go index afc1f0003cbe..4a31f85cc9e9 100644 --- a/x/bank/module.go +++ b/x/bank/module.go @@ -8,7 +8,7 @@ import ( "time" modulev1 "cosmossdk.io/api/cosmos/bank/module/v1" - "github.com/cosmos/cosmos-sdk/depinject" + "cosmossdk.io/depinject" store "github.com/cosmos/cosmos-sdk/store/types" paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" "github.com/tendermint/tendermint/crypto" diff --git a/x/capability/module.go b/x/capability/module.go index 3f994cb26b31..a4c3f5e818ad 100644 --- a/x/capability/module.go +++ b/x/capability/module.go @@ -13,10 +13,10 @@ import ( abci "github.com/tendermint/tendermint/abci/types" modulev1 "cosmossdk.io/api/cosmos/capability/module/v1" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/codec" cdctypes "github.com/cosmos/cosmos-sdk/codec/types" - "github.com/cosmos/cosmos-sdk/depinject" "github.com/cosmos/cosmos-sdk/runtime" store "github.com/cosmos/cosmos-sdk/store/types" "github.com/cosmos/cosmos-sdk/telemetry" diff --git a/x/capability/simulation/decoder_test.go b/x/capability/simulation/decoder_test.go index 484985bbbc7d..1c3c7e6d0dd5 100644 --- a/x/capability/simulation/decoder_test.go +++ b/x/capability/simulation/decoder_test.go @@ -6,8 +6,8 @@ import ( "github.com/stretchr/testify/require" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/codec" - "github.com/cosmos/cosmos-sdk/depinject" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/kv" "github.com/cosmos/cosmos-sdk/x/capability/simulation" diff --git a/x/crisis/module.go b/x/crisis/module.go index 8afbf8d89c0d..4b114baeb5ff 100644 --- a/x/crisis/module.go +++ b/x/crisis/module.go @@ -12,10 +12,10 @@ import ( abci "github.com/tendermint/tendermint/abci/types" modulev1 "cosmossdk.io/api/cosmos/crisis/module/v1" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/codec" codectypes "github.com/cosmos/cosmos-sdk/codec/types" - "github.com/cosmos/cosmos-sdk/depinject" "github.com/cosmos/cosmos-sdk/runtime" "github.com/cosmos/cosmos-sdk/server" servertypes "github.com/cosmos/cosmos-sdk/server/types" diff --git a/x/distribution/module.go b/x/distribution/module.go index be9b7f5e08e4..7366ce1d1adb 100644 --- a/x/distribution/module.go +++ b/x/distribution/module.go @@ -6,16 +6,16 @@ import ( "fmt" "math/rand" - modulev1 "cosmossdk.io/api/cosmos/distribution/module/v1" - "cosmossdk.io/core/appmodule" gwruntime "github.com/grpc-ecosystem/grpc-gateway/runtime" "github.com/spf13/cobra" abci "github.com/tendermint/tendermint/abci/types" + modulev1 "cosmossdk.io/api/cosmos/distribution/module/v1" + "cosmossdk.io/core/appmodule" + "cosmossdk.io/depinject" sdkclient "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/codec" cdctypes "github.com/cosmos/cosmos-sdk/codec/types" - "github.com/cosmos/cosmos-sdk/depinject" "github.com/cosmos/cosmos-sdk/runtime" store "github.com/cosmos/cosmos-sdk/store/types" sdk "github.com/cosmos/cosmos-sdk/types" diff --git a/x/distribution/simulation/decoder_test.go b/x/distribution/simulation/decoder_test.go index 37151379b5dc..4c00446108c6 100644 --- a/x/distribution/simulation/decoder_test.go +++ b/x/distribution/simulation/decoder_test.go @@ -6,9 +6,9 @@ import ( "github.com/stretchr/testify/require" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/codec" "github.com/cosmos/cosmos-sdk/crypto/keys/ed25519" - "github.com/cosmos/cosmos-sdk/depinject" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/kv" "github.com/cosmos/cosmos-sdk/x/distribution/simulation" diff --git a/x/evidence/keeper/querier_test.go b/x/evidence/keeper/querier_test.go index 45989b05f12b..e15412ba2b0e 100644 --- a/x/evidence/keeper/querier_test.go +++ b/x/evidence/keeper/querier_test.go @@ -3,8 +3,8 @@ package keeper_test import ( "strings" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/codec" - "github.com/cosmos/cosmos-sdk/depinject" "github.com/stretchr/testify/require" "github.com/cosmos/cosmos-sdk/x/evidence/exported" diff --git a/x/evidence/module.go b/x/evidence/module.go index 3e9bc7641af6..1b9759c34a69 100644 --- a/x/evidence/module.go +++ b/x/evidence/module.go @@ -11,10 +11,10 @@ import ( "github.com/spf13/cobra" abci "github.com/tendermint/tendermint/abci/types" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/codec" codectypes "github.com/cosmos/cosmos-sdk/codec/types" - "github.com/cosmos/cosmos-sdk/depinject" "github.com/cosmos/cosmos-sdk/runtime" store "github.com/cosmos/cosmos-sdk/store/types" sdk "github.com/cosmos/cosmos-sdk/types" diff --git a/x/evidence/simulation/decoder_test.go b/x/evidence/simulation/decoder_test.go index 2fa58f43fd18..fdba04c41c2a 100644 --- a/x/evidence/simulation/decoder_test.go +++ b/x/evidence/simulation/decoder_test.go @@ -7,8 +7,8 @@ import ( "github.com/stretchr/testify/require" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/crypto/keys/ed25519" - "github.com/cosmos/cosmos-sdk/depinject" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/kv" "github.com/cosmos/cosmos-sdk/x/evidence/keeper" diff --git a/x/feegrant/filtered_fee_test.go b/x/feegrant/filtered_fee_test.go index acda5c98c28b..4bda42a5b2cf 100644 --- a/x/feegrant/filtered_fee_test.go +++ b/x/feegrant/filtered_fee_test.go @@ -8,9 +8,9 @@ import ( "github.com/stretchr/testify/require" ocproto "github.com/tendermint/tendermint/proto/tendermint/types" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/codec" codectypes "github.com/cosmos/cosmos-sdk/codec/types" - "github.com/cosmos/cosmos-sdk/depinject" simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims" sdk "github.com/cosmos/cosmos-sdk/types" bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper" diff --git a/x/feegrant/migrations/v046/store_test.go b/x/feegrant/migrations/v046/store_test.go index 6d6f8828b867..eadf8c33ca9c 100644 --- a/x/feegrant/migrations/v046/store_test.go +++ b/x/feegrant/migrations/v046/store_test.go @@ -4,9 +4,9 @@ import ( "testing" "time" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/codec" "github.com/cosmos/cosmos-sdk/crypto/keys/ed25519" - "github.com/cosmos/cosmos-sdk/depinject" "github.com/cosmos/cosmos-sdk/testutil" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/feegrant" diff --git a/x/feegrant/module/module.go b/x/feegrant/module/module.go index d0fd9c0aef4e..77aa839f49ad 100644 --- a/x/feegrant/module/module.go +++ b/x/feegrant/module/module.go @@ -12,10 +12,10 @@ import ( modulev1 "cosmossdk.io/api/cosmos/feegrant/module/v1" + "cosmossdk.io/depinject" sdkclient "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/codec" cdctypes "github.com/cosmos/cosmos-sdk/codec/types" - "github.com/cosmos/cosmos-sdk/depinject" "github.com/cosmos/cosmos-sdk/runtime" store "github.com/cosmos/cosmos-sdk/store/types" sdk "github.com/cosmos/cosmos-sdk/types" diff --git a/x/feegrant/simulation/decoder_test.go b/x/feegrant/simulation/decoder_test.go index 0a6372403cdd..4652dd11461c 100644 --- a/x/feegrant/simulation/decoder_test.go +++ b/x/feegrant/simulation/decoder_test.go @@ -6,9 +6,9 @@ import ( "github.com/stretchr/testify/require" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/codec" "github.com/cosmos/cosmos-sdk/crypto/keys/ed25519" - "github.com/cosmos/cosmos-sdk/depinject" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/kv" "github.com/cosmos/cosmos-sdk/x/feegrant" diff --git a/x/genutil/module.go b/x/genutil/module.go index edce18408eda..0bf86f85d439 100644 --- a/x/genutil/module.go +++ b/x/genutil/module.go @@ -10,10 +10,10 @@ import ( "github.com/spf13/cobra" abci "github.com/tendermint/tendermint/abci/types" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/codec" cdctypes "github.com/cosmos/cosmos-sdk/codec/types" - "github.com/cosmos/cosmos-sdk/depinject" "github.com/cosmos/cosmos-sdk/runtime" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/module" diff --git a/x/gov/module.go b/x/gov/module.go index 2147096a39ff..ad54cdd9f696 100644 --- a/x/gov/module.go +++ b/x/gov/module.go @@ -9,19 +9,19 @@ import ( "math/rand" "sort" - modulev1 "cosmossdk.io/api/cosmos/gov/module/v1" - "cosmossdk.io/core/appmodule" gwruntime "github.com/grpc-ecosystem/grpc-gateway/runtime" "github.com/spf13/cobra" abci "github.com/tendermint/tendermint/abci/types" "golang.org/x/exp/maps" "golang.org/x/exp/slices" + modulev1 "cosmossdk.io/api/cosmos/gov/module/v1" + "cosmossdk.io/core/appmodule" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/baseapp" "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/codec" codectypes "github.com/cosmos/cosmos-sdk/codec/types" - "github.com/cosmos/cosmos-sdk/depinject" "github.com/cosmos/cosmos-sdk/runtime" store "github.com/cosmos/cosmos-sdk/store/types" sdk "github.com/cosmos/cosmos-sdk/types" diff --git a/x/group/module/module.go b/x/group/module/module.go index 4f234220426c..3adaff5d0155 100644 --- a/x/group/module/module.go +++ b/x/group/module/module.go @@ -12,11 +12,11 @@ import ( abci "github.com/tendermint/tendermint/abci/types" modulev1 "cosmossdk.io/api/cosmos/group/module/v1" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/baseapp" sdkclient "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/codec" cdctypes "github.com/cosmos/cosmos-sdk/codec/types" - "github.com/cosmos/cosmos-sdk/depinject" "github.com/cosmos/cosmos-sdk/runtime" store "github.com/cosmos/cosmos-sdk/store/types" sdk "github.com/cosmos/cosmos-sdk/types" diff --git a/x/group/proposal_test.go b/x/group/proposal_test.go index 2ad781f7a3b8..8e741908db70 100644 --- a/x/group/proposal_test.go +++ b/x/group/proposal_test.go @@ -5,8 +5,8 @@ import ( "github.com/stretchr/testify/require" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/codec" - "github.com/cosmos/cosmos-sdk/depinject" "github.com/cosmos/cosmos-sdk/x/group" "github.com/cosmos/cosmos-sdk/x/group/testutil" ) diff --git a/x/group/simulation/decoder_test.go b/x/group/simulation/decoder_test.go index b5de0c3f4305..74106303f6ba 100644 --- a/x/group/simulation/decoder_test.go +++ b/x/group/simulation/decoder_test.go @@ -6,8 +6,8 @@ import ( "github.com/stretchr/testify/require" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/codec" - "github.com/cosmos/cosmos-sdk/depinject" "github.com/cosmos/cosmos-sdk/testutil/testdata" "github.com/cosmos/cosmos-sdk/types/kv" "github.com/cosmos/cosmos-sdk/x/group" diff --git a/x/group/simulation/genesis_test.go b/x/group/simulation/genesis_test.go index d05e52495264..db09434920ac 100644 --- a/x/group/simulation/genesis_test.go +++ b/x/group/simulation/genesis_test.go @@ -7,9 +7,9 @@ import ( "github.com/stretchr/testify/require" + "cosmossdk.io/depinject" sdkmath "cosmossdk.io/math" "github.com/cosmos/cosmos-sdk/codec" - "github.com/cosmos/cosmos-sdk/depinject" "github.com/cosmos/cosmos-sdk/types/module" simtypes "github.com/cosmos/cosmos-sdk/types/simulation" "github.com/cosmos/cosmos-sdk/x/group" diff --git a/x/mint/module.go b/x/mint/module.go index c4df3df779a6..7945b4abee73 100644 --- a/x/mint/module.go +++ b/x/mint/module.go @@ -12,10 +12,10 @@ import ( "github.com/spf13/cobra" abci "github.com/tendermint/tendermint/abci/types" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/codec" cdctypes "github.com/cosmos/cosmos-sdk/codec/types" - "github.com/cosmos/cosmos-sdk/depinject" "github.com/cosmos/cosmos-sdk/runtime" store "github.com/cosmos/cosmos-sdk/store/types" sdk "github.com/cosmos/cosmos-sdk/types" diff --git a/x/nft/module/module.go b/x/nft/module/module.go index 2532b8fab793..51f08ff123e5 100644 --- a/x/nft/module/module.go +++ b/x/nft/module/module.go @@ -10,10 +10,10 @@ import ( abci "github.com/tendermint/tendermint/abci/types" "cosmossdk.io/core/appmodule" + "cosmossdk.io/depinject" sdkclient "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/codec" cdctypes "github.com/cosmos/cosmos-sdk/codec/types" - "github.com/cosmos/cosmos-sdk/depinject" "github.com/cosmos/cosmos-sdk/runtime" store "github.com/cosmos/cosmos-sdk/store/types" sdk "github.com/cosmos/cosmos-sdk/types" diff --git a/x/params/keeper/common_test.go b/x/params/keeper/common_test.go index dfd0aa34e793..27b6295a65b1 100644 --- a/x/params/keeper/common_test.go +++ b/x/params/keeper/common_test.go @@ -1,8 +1,8 @@ package keeper_test import ( + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/codec" - "github.com/cosmos/cosmos-sdk/depinject" storetypes "github.com/cosmos/cosmos-sdk/store/types" sdktestutil "github.com/cosmos/cosmos-sdk/testutil" sdk "github.com/cosmos/cosmos-sdk/types" diff --git a/x/params/module.go b/x/params/module.go index ef64bcbf93e2..535920c6a25e 100644 --- a/x/params/module.go +++ b/x/params/module.go @@ -3,16 +3,17 @@ package params import ( "context" "encoding/json" - govv1beta1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1beta1" "math/rand" + govv1beta1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1beta1" + gwruntime "github.com/grpc-ecosystem/grpc-gateway/runtime" "github.com/spf13/cobra" abci "github.com/tendermint/tendermint/abci/types" modulev1 "cosmossdk.io/api/cosmos/params/module/v1" "cosmossdk.io/core/appmodule" - "github.com/cosmos/cosmos-sdk/depinject" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/runtime" "github.com/cosmos/cosmos-sdk/baseapp" diff --git a/x/params/types/subspace_test.go b/x/params/types/subspace_test.go index 4a967c42b231..63874489dc6e 100644 --- a/x/params/types/subspace_test.go +++ b/x/params/types/subspace_test.go @@ -11,8 +11,8 @@ import ( tmproto "github.com/tendermint/tendermint/proto/tendermint/types" dbm "github.com/tendermint/tm-db" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/codec" - "github.com/cosmos/cosmos-sdk/depinject" "github.com/cosmos/cosmos-sdk/store" storetypes "github.com/cosmos/cosmos-sdk/store/types" sdk "github.com/cosmos/cosmos-sdk/types" diff --git a/x/slashing/module.go b/x/slashing/module.go index a06c434b4992..a9d30d85afab 100644 --- a/x/slashing/module.go +++ b/x/slashing/module.go @@ -14,10 +14,10 @@ import ( "github.com/spf13/cobra" abci "github.com/tendermint/tendermint/abci/types" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/codec" cdctypes "github.com/cosmos/cosmos-sdk/codec/types" - "github.com/cosmos/cosmos-sdk/depinject" "github.com/cosmos/cosmos-sdk/runtime" store "github.com/cosmos/cosmos-sdk/store/types" govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" diff --git a/x/slashing/simulation/decoder_test.go b/x/slashing/simulation/decoder_test.go index 15e6acf33cef..52fe08083ae1 100644 --- a/x/slashing/simulation/decoder_test.go +++ b/x/slashing/simulation/decoder_test.go @@ -8,9 +8,9 @@ import ( gogotypes "github.com/gogo/protobuf/types" "github.com/stretchr/testify/require" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/codec" "github.com/cosmos/cosmos-sdk/crypto/keys/ed25519" - "github.com/cosmos/cosmos-sdk/depinject" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/kv" "github.com/cosmos/cosmos-sdk/x/slashing/simulation" diff --git a/x/slashing/simulation/genesis_test.go b/x/slashing/simulation/genesis_test.go index 99c9e010dd3a..6cf18bb751b8 100644 --- a/x/slashing/simulation/genesis_test.go +++ b/x/slashing/simulation/genesis_test.go @@ -8,10 +8,10 @@ import ( "github.com/stretchr/testify/require" + "cosmossdk.io/depinject" sdkmath "cosmossdk.io/math" "github.com/cosmos/cosmos-sdk/codec" codectypes "github.com/cosmos/cosmos-sdk/codec/types" - "github.com/cosmos/cosmos-sdk/depinject" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/module" simtypes "github.com/cosmos/cosmos-sdk/types/simulation" diff --git a/x/staking/module.go b/x/staking/module.go index 944d7d4842f8..f748d2e5a278 100644 --- a/x/staking/module.go +++ b/x/staking/module.go @@ -7,17 +7,17 @@ import ( "math/rand" "sort" - modulev1 "cosmossdk.io/api/cosmos/staking/module/v1" - "cosmossdk.io/core/appmodule" gwruntime "github.com/grpc-ecosystem/grpc-gateway/runtime" "github.com/spf13/cobra" abci "github.com/tendermint/tendermint/abci/types" "golang.org/x/exp/maps" + modulev1 "cosmossdk.io/api/cosmos/staking/module/v1" + "cosmossdk.io/core/appmodule" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/codec" cdctypes "github.com/cosmos/cosmos-sdk/codec/types" - "github.com/cosmos/cosmos-sdk/depinject" "github.com/cosmos/cosmos-sdk/runtime" store "github.com/cosmos/cosmos-sdk/store/types" sdk "github.com/cosmos/cosmos-sdk/types" diff --git a/x/upgrade/abci_test.go b/x/upgrade/abci_test.go index 878f1f0ab0db..b76185452b09 100644 --- a/x/upgrade/abci_test.go +++ b/x/upgrade/abci_test.go @@ -12,9 +12,9 @@ import ( tmproto "github.com/tendermint/tendermint/proto/tendermint/types" "golang.org/x/exp/maps" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/client/flags" "github.com/cosmos/cosmos-sdk/codec" - "github.com/cosmos/cosmos-sdk/depinject" "github.com/cosmos/cosmos-sdk/server" simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims" sdk "github.com/cosmos/cosmos-sdk/types" diff --git a/x/upgrade/keeper/keeper_test.go b/x/upgrade/keeper/keeper_test.go index c9e2b0536023..d2e8274f6c95 100644 --- a/x/upgrade/keeper/keeper_test.go +++ b/x/upgrade/keeper/keeper_test.go @@ -8,8 +8,8 @@ import ( "github.com/stretchr/testify/suite" tmproto "github.com/tendermint/tendermint/proto/tendermint/types" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/baseapp" - "github.com/cosmos/cosmos-sdk/depinject" simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/module" diff --git a/x/upgrade/module.go b/x/upgrade/module.go index 74df9aafa733..6589b63343b8 100644 --- a/x/upgrade/module.go +++ b/x/upgrade/module.go @@ -3,6 +3,7 @@ package upgrade import ( "context" "encoding/json" + govv1beta1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1beta1" gwruntime "github.com/grpc-ecosystem/grpc-gateway/runtime" @@ -11,11 +12,11 @@ import ( abci "github.com/tendermint/tendermint/abci/types" "cosmossdk.io/core/appmodule" + "cosmossdk.io/depinject" "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/client/flags" "github.com/cosmos/cosmos-sdk/codec" codectypes "github.com/cosmos/cosmos-sdk/codec/types" - "github.com/cosmos/cosmos-sdk/depinject" "github.com/cosmos/cosmos-sdk/runtime" "github.com/cosmos/cosmos-sdk/server" servertypes "github.com/cosmos/cosmos-sdk/server/types" From b10fa1d9ce5c2bdc87a658ba83af4b37d1888b62 Mon Sep 17 00:00:00 2001 From: Julien Robert Date: Mon, 11 Jul 2022 15:43:04 +0200 Subject: [PATCH 16/37] chore: upgrade tm-db (#12511) --- cosmovisor/cmd/cosmovisor/version.go | 3 +- cosmovisor/go.mod | 22 ++- cosmovisor/go.sum | 215 ++++++++++++++++++++++++--- go.mod | 10 +- go.sum | 8 +- store/tools/ics23/go.mod | 8 +- store/tools/ics23/go.sum | 17 ++- 7 files changed, 230 insertions(+), 53 deletions(-) diff --git a/cosmovisor/cmd/cosmovisor/version.go b/cosmovisor/cmd/cosmovisor/version.go index de5005a721f4..617f6bd88d52 100644 --- a/cosmovisor/cmd/cosmovisor/version.go +++ b/cosmovisor/cmd/cosmovisor/version.go @@ -8,7 +8,6 @@ import ( "github.com/cosmos/cosmos-sdk/cosmovisor" "github.com/rs/zerolog" "github.com/spf13/cobra" - tmcli "github.com/tendermint/tendermint/libs/cli" ) func init() { @@ -20,7 +19,7 @@ var ( // Version represents Cosmovisor version value. Overwritten during build Version = "1.1.0" // OutputFlag defines the output format flag - OutputFlag = tmcli.OutputFlag + OutputFlag = "output" ) var versionCmd = &cobra.Command{ diff --git a/cosmovisor/go.mod b/cosmovisor/go.mod index 362873b0bae0..be5e574549d7 100644 --- a/cosmovisor/go.mod +++ b/cosmovisor/go.mod @@ -3,13 +3,12 @@ module github.com/cosmos/cosmos-sdk/cosmovisor go 1.18 require ( - github.com/cosmos/cosmos-sdk v0.46.0-rc1 + github.com/cosmos/cosmos-sdk v0.46.0-rc2 github.com/hashicorp/go-getter v1.6.2 github.com/otiai10/copy v1.7.0 github.com/rs/zerolog v1.27.0 github.com/spf13/cobra v1.5.0 github.com/stretchr/testify v1.8.0 - github.com/tendermint/tendermint v0.35.7 ) require ( @@ -17,10 +16,11 @@ require ( cloud.google.com/go/compute v1.6.1 // indirect cloud.google.com/go/iam v0.3.0 // indirect cloud.google.com/go/storage v1.14.0 // indirect - cosmossdk.io/errors v1.0.0-beta.6 // indirect + cosmossdk.io/errors v1.0.0-beta.7 // indirect cosmossdk.io/math v1.0.0-beta.2 // indirect filippo.io/edwards25519 v1.0.0-rc.1 // indirect github.com/99designs/keyring v1.1.6 // indirect + github.com/ChainSafe/go-schnorrkel v0.0.0-20200405005733-88cbf1b4c40d // indirect github.com/armon/go-metrics v0.3.11 // indirect github.com/aws/aws-sdk-go v1.40.45 // indirect github.com/beorn7/perks v1.0.1 // indirect @@ -33,7 +33,7 @@ require ( github.com/cosmos/btcutil v1.0.4 // indirect github.com/cosmos/cosmos-proto v1.0.0-alpha7 // indirect github.com/cosmos/go-bip39 v1.0.0 // indirect - github.com/cosmos/iavl v0.18.0 // indirect + github.com/cosmos/iavl v0.17.3 // indirect github.com/cosmos/ledger-cosmos-go v0.11.1 // indirect github.com/cosmos/ledger-go v0.9.2 // indirect github.com/danieljoos/wincred v1.0.2 // indirect @@ -44,19 +44,23 @@ require ( github.com/dustin/go-humanize v1.0.0 // indirect github.com/dvsekhvalnov/jose2go v0.0.0-20200901110807-248326c1351b // indirect github.com/fsnotify/fsnotify v1.5.4 // indirect + github.com/go-kit/kit v0.12.0 // indirect + github.com/go-kit/log v0.2.1 // indirect + github.com/go-logfmt/logfmt v0.5.1 // indirect github.com/godbus/dbus v0.0.0-20190726142602-4481cbc300e2 // indirect - github.com/gogo/protobuf v1.3.3 // indirect + github.com/gogo/protobuf v1.3.2 // indirect github.com/golang/glog v1.0.0 // indirect github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect github.com/golang/protobuf v1.5.2 // indirect github.com/golang/snappy v0.0.4 // indirect github.com/google/btree v1.0.1 // indirect - github.com/google/uuid v1.3.0 // indirect github.com/googleapis/gax-go/v2 v2.4.0 // indirect github.com/gorilla/websocket v1.5.0 // indirect github.com/grpc-ecosystem/go-grpc-middleware v1.3.0 // indirect github.com/grpc-ecosystem/grpc-gateway v1.16.0 // indirect github.com/gsterjov/go-libsecret v0.0.0-20161001094733-a6f4afe4910c // indirect + github.com/gtank/merlin v0.1.1 // indirect + github.com/gtank/ristretto255 v0.1.2 // indirect github.com/hashicorp/go-cleanhttp v0.5.2 // indirect github.com/hashicorp/go-immutable-radix v1.3.1 // indirect github.com/hashicorp/go-safetemp v1.0.0 // indirect @@ -68,16 +72,17 @@ require ( github.com/jmespath/go-jmespath v0.4.0 // indirect github.com/jmhodges/levigo v1.0.0 // indirect github.com/keybase/go-keychain v0.0.0-20190712205309-48d3d31d256d // indirect - github.com/klauspost/compress v1.13.6 // indirect + github.com/klauspost/compress v1.15.1 // indirect + github.com/libp2p/go-buffer-pool v0.0.2 // indirect github.com/magiconair/properties v1.8.6 // indirect github.com/mattn/go-colorable v0.1.12 // indirect github.com/mattn/go-isatty v0.0.14 // indirect github.com/matttproud/golang_protobuf_extensions v1.0.1 // indirect + github.com/mimoo/StrobeGo v0.0.0-20181016162300-f8f6d4d2b643 // indirect github.com/mitchellh/go-homedir v1.1.0 // indirect github.com/mitchellh/go-testing-interface v1.0.0 // indirect github.com/mitchellh/mapstructure v1.5.0 // indirect github.com/mtibben/percent v0.2.1 // indirect - github.com/oasisprotocol/curve25519-voi v0.0.0-20210609091139-0a56a4bca00b // indirect github.com/pelletier/go-toml v1.9.5 // indirect github.com/pelletier/go-toml/v2 v2.0.2 // indirect github.com/petermattis/goid v0.0.0-20180202154549-b0b1615b78e5 // indirect @@ -100,6 +105,7 @@ require ( github.com/tendermint/btcd v0.1.1 // indirect github.com/tendermint/crypto v0.0.0-20191022145703-50d29ede1e15 // indirect github.com/tendermint/go-amino v0.16.0 // indirect + github.com/tendermint/tendermint v0.34.20-rc0 // indirect github.com/tendermint/tm-db v0.6.6 // indirect github.com/ulikunitz/xz v0.5.8 // indirect github.com/zondax/hid v0.9.1-0.20220302062450-5552068d2266 // indirect diff --git a/cosmovisor/go.sum b/cosmovisor/go.sum index a20d87dafe6c..c3cc496cbe8c 100644 --- a/cosmovisor/go.sum +++ b/cosmovisor/go.sum @@ -48,6 +48,7 @@ cloud.google.com/go/compute v1.6.1 h1:2sMmt8prCn7DPaG4Pmh0N3Inmc8cT8ae5k1M6VJ9Wq cloud.google.com/go/compute v1.6.1/go.mod h1:g85FgpzFvNULZ+S8AYq87axRKuf2Kh7deLqV/jJ3thU= cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE= cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk= +cloud.google.com/go/firestore v1.1.0/go.mod h1:ulACoGHTpvq5r8rxGJ4ddJZBZqakUQqClKRT5SZwBmk= cloud.google.com/go/firestore v1.6.1/go.mod h1:asNXNOzBdyVQmEU+ggO8UPodTkEVFW5Qx+rwHnAz+EY= cloud.google.com/go/iam v0.3.0 h1:exkAomrVUuzx9kWFI1wm3KI0uoDeUFPB4kKGzx6x+Gc= cloud.google.com/go/iam v0.3.0/go.mod h1:XzJPvDayI+9zsASAFO68Hk07u3z+f+JrT2xXNdp4bnY= @@ -66,8 +67,8 @@ cloud.google.com/go/storage v1.14.0 h1:6RRlFMv1omScs6iq2hfE3IvgE+l6RfJPampq8UZc5 cloud.google.com/go/storage v1.14.0/go.mod h1:GrKmX003DSIwi9o29oFT7YDnHYwZoctc3fOKtUw0Xmo= contrib.go.opencensus.io/exporter/stackdriver v0.13.4/go.mod h1:aXENhDJ1Y4lIg4EUaVTwzvYETVNZk10Pu26tevFKLUc= cosmossdk.io/api v0.1.0-alpha8 h1:Hr+8bLI4UphF+aMiDIVklrdzRm99dFaNq2inBKGDzNU= -cosmossdk.io/errors v1.0.0-beta.6 h1:aIn9ZemUfjdgVHNuAgEcKklbOa+ygv6u9gbWOGvzIoU= -cosmossdk.io/errors v1.0.0-beta.6/go.mod h1:mz6FQMJRku4bY7aqS/Gwfcmr/ue91roMEKAmDUDpBfE= +cosmossdk.io/errors v1.0.0-beta.7 h1:gypHW76pTQGVnHKo6QBkb4yFOJjC+sUGRc5Al3Odj1w= +cosmossdk.io/errors v1.0.0-beta.7/go.mod h1:mz6FQMJRku4bY7aqS/Gwfcmr/ue91roMEKAmDUDpBfE= cosmossdk.io/math v1.0.0-beta.2 h1:17hSVc9ne1c31IaLDfjRojtN+y4Rd2N8H/6Fht2sBzw= cosmossdk.io/math v1.0.0-beta.2/go.mod h1:u/MXvf8wbUbCsAEyQSSYXXMsczAsFX48e2D6JI86T4o= dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU= @@ -86,6 +87,8 @@ github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03 github.com/BurntSushi/toml v0.4.1/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ= github.com/BurntSushi/toml v1.1.0/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ= github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo= +github.com/ChainSafe/go-schnorrkel v0.0.0-20200405005733-88cbf1b4c40d h1:nalkkPQcITbvhmL4+C4cKA87NW0tfm3Kl9VXRoPywFg= +github.com/ChainSafe/go-schnorrkel v0.0.0-20200405005733-88cbf1b4c40d/go.mod h1:URdX5+vg25ts3aCh8H5IFZybJYKWhJHYMTnf+ULtoC4= github.com/DATA-DOG/go-sqlmock v1.5.0/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM= github.com/DataDog/datadog-go v3.2.0+incompatible/go.mod h1:LButxg5PwREeZtORoXG3tL4fMGNddJ+vMq1mwgfaqoQ= github.com/DataDog/zstd v1.4.1/go.mod h1:1jcaCB/ufaK+sKp1NBhlGmpz41jOoPQ35bpF36t7BBo= @@ -99,6 +102,8 @@ github.com/Masterminds/semver v1.4.2/go.mod h1:MB6lktGJrhw8PrUyiEoblNEGEQ+RzHPF0 github.com/Masterminds/semver v1.5.0/go.mod h1:MB6lktGJrhw8PrUyiEoblNEGEQ+RzHPF078ddwwvV3Y= github.com/Masterminds/sprig v2.15.0+incompatible/go.mod h1:y6hNFY5UBTIWBxnzTeuNhlNS5hqE0NB0E6fgfo2Br3o= github.com/Masterminds/sprig v2.22.0+incompatible/go.mod h1:y6hNFY5UBTIWBxnzTeuNhlNS5hqE0NB0E6fgfo2Br3o= +github.com/Microsoft/go-winio v0.4.14/go.mod h1:qXqCSQ3Xa7+6tgxaGTIe4Kpcdsi+P8jBhyzoq1bpyYA= +github.com/Microsoft/go-winio v0.5.0/go.mod h1:JPGBdM1cNvN/6ISo+n8V5iA4v8pBzdOpzfwIujj1a84= github.com/Microsoft/go-winio v0.5.2/go.mod h1:WpS1mjBmmwHBEWmogvA2mj8546UReBk4v8QkMxJ6pZY= github.com/Nvveen/Gotty v0.0.0-20120604004816-cd527374f1e5/go.mod h1:lmUJ/7eu/Q8D7ML55dXQrVaamCz2vxCfdQBasLZfHKk= github.com/OneOfOne/xxhash v1.2.2 h1:KMrpdQIwFcEqXDklaen+P1axHaj9BSKzvpUUfnHldSE= @@ -106,9 +111,12 @@ github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAE github.com/OpenPeeDeeP/depguard v1.1.0/go.mod h1:JtAMzWkmFEzDPyAd+W0NHl1lvpQKTvT9jnRVsohBKpc= github.com/Shopify/sarama v1.19.0/go.mod h1:FVkBWblsNy7DGZRfXLU0O9RCGt5g3g3yEuWXgklEdEo= github.com/Shopify/toxiproxy v2.1.4+incompatible/go.mod h1:OXgGpZ6Cli1/URJOF1DMxUHB2q5Ap20/P/eIdh4G0pI= +github.com/VividCortex/gohistogram v1.0.0 h1:6+hBz+qvs0JOrrNhhmR7lFxo5sINxBCGXrdtl/UvroE= github.com/VividCortex/gohistogram v1.0.0/go.mod h1:Pf5mBqqDxYaXu3hDrrU+w6nw50o/4+TcAqDqk/vUH7g= +github.com/Workiva/go-datastructures v1.0.52/go.mod h1:Z+F2Rca0qCsVYDS8z7bAGm8f3UkzuWYS/oBZz5a7VVA= github.com/Workiva/go-datastructures v1.0.53 h1:J6Y/52yX10Xc5JjXmGtWoSSxs3mZnGSaq37xZZh7Yig= github.com/Workiva/go-datastructures v1.0.53/go.mod h1:1yZL+zfsztete+ePzZz/Zb1/t5BnDuE2Ya2MMGhzP6A= +github.com/adlio/schema v1.1.13/go.mod h1:L5Z7tw+7lRK1Fnpi/LT/ooCP1elkXn0krMWBQHUhEDE= github.com/adlio/schema v1.3.3/go.mod h1:1EsRssiv9/Ce2CMzq5DoL7RiMshhuigQxrR4DMV9fHg= github.com/aead/siphash v1.0.1/go.mod h1:Nywa3cDsYNNK3gaciGTWPwHt0wlpNV15vwmswBAUSII= github.com/afex/hystrix-go v0.0.0-20180502004556-fa1af6a1f4f5/go.mod h1:SkGFH1ia65gfNATL8TAiHDNxPzPdmEL5uirI2Uyuz6c= @@ -124,6 +132,8 @@ github.com/andybalholm/brotli v1.0.3/go.mod h1:fO7iG3H7G2nSZ7m0zPUDn85XEX2GTukHG github.com/antihax/optional v0.0.0-20180407024304-ca021399b1a6/go.mod h1:V8iCPQYkqmusNa815XgQio277wI47sdRh1dUOLdyC6Q= github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY= github.com/aokoli/goutils v1.0.1/go.mod h1:SijmP0QR8LtwsmDs8Yii5Z/S4trXFGFC2oO5g9DP+DQ= +github.com/apache/thrift v0.12.0/go.mod h1:cp2SuWMxlEZw2r+iP2GNCdIi4C1qmUzdZFSVb+bacwQ= +github.com/apache/thrift v0.13.0/go.mod h1:cp2SuWMxlEZw2r+iP2GNCdIi4C1qmUzdZFSVb+bacwQ= github.com/armon/circbuf v0.0.0-20150827004946-bbbad097214e/go.mod h1:3U/XgcO3hCbHZ8TKRvWD2dDTCfh9M9ya+I9JpbB7O8o= github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8= github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da/go.mod h1:Q73ZrmVTwzkszR9V5SSuryQ31EELlFMUz1kKyl939pY= @@ -133,18 +143,23 @@ github.com/armon/go-metrics v0.3.11 h1:/q4zqTAH+/mtFjimfc0SC7yuuxZshlS4TaCeBm+7s github.com/armon/go-metrics v0.3.11/go.mod h1:4O98XIr/9W0sxpJ8UaYkvjk10Iff7SnFrb4QAOwNTFc= github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8= github.com/armon/go-radix v1.0.0/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8= +github.com/aryann/difflib v0.0.0-20170710044230-e206f873d14a/go.mod h1:DAHtR1m6lCRdSC2Tm3DSWRPvIPr6xNKyeHdqDQSQT+A= github.com/ashanbrown/forbidigo v1.3.0/go.mod h1:vVW7PEdqEFqapJe95xHkTfB1+XvZXBFg8t0sG2FIxmI= github.com/ashanbrown/makezero v1.1.1/go.mod h1:i1bJLCRSCHOcOa9Y6MyF2FTfMZMFdHvxKHxgO5Z1axI= +github.com/aws/aws-lambda-go v1.13.3/go.mod h1:4UKl9IzQMoD+QF79YdCuzCwp8VbmG4VAQwij/eHl5CU= github.com/aws/aws-sdk-go v1.15.78/go.mod h1:E3/ieXAlvM0XWO57iftYVDLLvQ824smPP3ATZkfNZeM= github.com/aws/aws-sdk-go v1.23.20/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo= github.com/aws/aws-sdk-go v1.25.37/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo= +github.com/aws/aws-sdk-go v1.27.0/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo= github.com/aws/aws-sdk-go v1.36.30/go.mod h1:hcU610XS61/+aQV88ixoOzUoG7v3b31pl2zKMmprdro= github.com/aws/aws-sdk-go v1.40.45 h1:QN1nsY27ssD/JmW4s83qmSb+uL6DG4GmCDzjmJB4xUI= github.com/aws/aws-sdk-go v1.40.45/go.mod h1:585smgzpB/KqRA+K3y/NL/oYRqQvpNJYvLm+LY1U59Q= +github.com/aws/aws-sdk-go-v2 v0.18.0/go.mod h1:JWVYvqSMppoMJC0x5wdwiImzgXTI9FuZwxzkQq9wy+g= github.com/aws/aws-sdk-go-v2 v1.9.1/go.mod h1:cK/D0BBs0b/oWPIcX/Z/obahJK1TT7IPVjy53i/mX/4= github.com/aws/aws-sdk-go-v2/service/cloudwatch v1.8.1/go.mod h1:CM+19rL1+4dFWnOQKwDc7H1KwXTz+h61oUSHyhV0b3o= github.com/aws/smithy-go v1.8.0/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA= +github.com/benbjohnson/clock v1.3.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA= github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q= github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8= github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= @@ -153,6 +168,8 @@ github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d h1:xDfNPAt8lFiC1U github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d/go.mod h1:6QX/PXZ00z/TKoufEY6K/a0k6AhaJrQKdFe6OfVXsa4= github.com/bgentry/speakeasy v0.1.0 h1:ByYyxL9InA1OWqxJqqp2A5pYHUrCiAL6K3J+LKSsQkY= github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs= +github.com/bits-and-blooms/bitset v1.2.0/go.mod h1:gIdJ4wp64HaoK2YrL1Q5/N7Y16edYb8uY+O0FJTyyDA= +github.com/bketelsen/crypt v0.0.3-0.20200106085610-5cbc8cc4026c/go.mod h1:MKsuJmJgSg28kpZDP6UIiPt0e0Oz0kqKNGyRaWEPv84= github.com/bkielbasa/cyclop v1.2.0/go.mod h1:qOI0yy6A7dYC4Zgsa72Ppm9kONl0RoIlPbzot9mhmeI= github.com/blizzy78/varnamelen v0.8.0/go.mod h1:V9TzQZ4fLJ1DSrjVDfl89H7aMnTvKkApdHeyESmyR7k= github.com/bombsimon/wsl/v3 v3.3.0/go.mod h1:st10JtZYLE4D5sC7b8xV4zTKZwAQjCH/Hy2Pm1FNZIc= @@ -160,6 +177,7 @@ github.com/breml/bidichk v0.2.3/go.mod h1:8u2C6DnAy0g2cEq+k/A2+tr9O1s+vHGxWn0LTc github.com/breml/errchkjson v0.3.0/go.mod h1:9Cogkyv9gcT8HREpzi3TiqBxCqDzo8awa92zSDFcofU= github.com/btcsuite/btcd v0.0.0-20190115013929-ed77733ec07d/go.mod h1:d3C0AkH6BRcvO8T0UEPu53cnw4IbV63x1bEjildYhO0= github.com/btcsuite/btcd v0.20.1-beta/go.mod h1:wVuoA8VJLEcwgqHBwHmzLRazpKxTv13Px/pDuV7OomQ= +github.com/btcsuite/btcd v0.21.0-beta/go.mod h1:ZSWyehm27aAuS9bvkATT+Xte3hjHZ+MRgMY/8NJ7K94= github.com/btcsuite/btcd v0.22.1 h1:CnwP9LM/M9xuRrGSCGeMVs9iv09uMqwsVX7EeIpgV2c= github.com/btcsuite/btcd v0.22.1/go.mod h1:wqgTSL29+50LRkmOVknEdmt8ZojIzhuWvgu/iptuN7Y= github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1 h1:q0rUy8C/TYNBQS1+CGKw68tLOFYSNEs0TFnxxnS9+4U= @@ -167,6 +185,7 @@ github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1/go.mod h1:7SFka0XMvUgj3hfZtyd github.com/btcsuite/btclog v0.0.0-20170628155309-84c8d2346e9f/go.mod h1:TdznJufoqS23FtqVCzL0ZqgP5MqXbb4fg/WgDys70nA= github.com/btcsuite/btcutil v0.0.0-20180706230648-ab6388e0c60a/go.mod h1:+5NJ2+qvTyV9exUAL/rxXi3DcLg2Ts+ymUAY5y4NvMg= github.com/btcsuite/btcutil v0.0.0-20190425235716-9e5f4b9a998d/go.mod h1:+5NJ2+qvTyV9exUAL/rxXi3DcLg2Ts+ymUAY5y4NvMg= +github.com/btcsuite/btcutil v1.0.2/go.mod h1:j9HUFwoQRsZL3V4n+qG+CUnEGHOarIxfC3Le2Yhbcts= github.com/btcsuite/btcutil v1.0.3-0.20201208143702-a53e38424cce h1:YtWJF7RHm2pYCvA5t0RPmAaLUhREsKuKd+SLhxFbFeQ= github.com/btcsuite/btcutil v1.0.3-0.20201208143702-a53e38424cce/go.mod h1:0DVlHczLPewLcPGEIeUEzfOJhqGPQ0mJJRDBtD307+o= github.com/btcsuite/go-socks v0.0.0-20170105172521-4720035b7bfd/go.mod h1:HHNXQzUsZCxOoE+CPiyCTO6x34Zs86zZUiwtpXoGdtg= @@ -176,7 +195,9 @@ github.com/btcsuite/snappy-go v0.0.0-20151229074030-0bdef8d06723/go.mod h1:8woku github.com/btcsuite/snappy-go v1.0.0/go.mod h1:8woku9dyThutzjeg+3xrA5iCpBRH8XEEg3lh6TiUghc= github.com/btcsuite/websocket v0.0.0-20150119174127-31079b680792/go.mod h1:ghJtEyQwv5/p4Mg4C0fgbePVuGr935/5ddU9Z3TmDRY= github.com/btcsuite/winsvc v1.0.0/go.mod h1:jsenWakMcC0zFBFurPLEAyrnc/teJEM1O46fmI40EZs= +github.com/bufbuild/buf v1.4.0/go.mod h1:mwHG7klTHnX+rM/ym8LXGl7vYpVmnwT96xWoRB4H5QI= github.com/butuzov/ireturn v0.1.1/go.mod h1:Wh6Zl3IMtTpaIKbmwzqi6olnM9ptYQxxVacMsOEFPoc= +github.com/casbin/casbin/v2 v2.1.2/go.mod h1:YcPU1XXisHhLzuxH9coDNf2FbKpjGlbCg3n9yuLkIJQ= github.com/casbin/casbin/v2 v2.37.0/go.mod h1:vByNa/Fchek0KZUgG5wEsl7iFsiviAYKRtgrQfcJqHg= github.com/cenkalti/backoff v2.2.1+incompatible h1:tNowT99t7UNflLxfYYSlKYsBpXdEet03Pg2g16Swow4= github.com/cenkalti/backoff v2.2.1+incompatible/go.mod h1:90ReRw6GdpyfrHakVjL/QHaoyV4aDUVVkXQJJJ3NXXM= @@ -192,15 +213,18 @@ github.com/cespare/xxhash/v2 v2.1.2 h1:YRXhKfTDauu4ajMg1TPgFO5jnlC2HCbmLXMcTG5cb github.com/cespare/xxhash/v2 v2.1.2/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/charithe/durationcheck v0.0.9/go.mod h1:SSbRIBVfMjCi/kEB6K65XEA83D6prSM8ap1UCpNKtgg= github.com/chavacava/garif v0.0.0-20220316182200-5cad0b5181d4/go.mod h1:W8EnPSQ8Nv4fUjc/v1/8tHFqhuOJXnRub0dTfuAQktU= +github.com/checkpoint-restore/go-criu/v5 v5.0.0/go.mod h1:cfwC0EG7HMUenopBsUf9d89JlCLQIfgVcNsNN0t6T2M= github.com/checkpoint-restore/go-criu/v5 v5.3.0/go.mod h1:E/eQpaFtUKGOOSEBZgmKAcn+zUUwWxqcaKZlF54wK8E= github.com/cheggaaa/pb v1.0.27/go.mod h1:pQciLPpbU0oxA0h+VJYYLxO+XeDQb5pZijXscXHm81s= github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI= github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI= github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU= +github.com/cilium/ebpf v0.6.2/go.mod h1:4tRaxcgiL706VnOzHOdBlY8IEAIdxINsQBcU4xJJXRs= github.com/cilium/ebpf v0.7.0/go.mod h1:/oI2+1shJiTGAMgl6/RgJr36Eo1jzrRcAWbcXO2usCA= github.com/circonus-labs/circonus-gometrics v2.3.1+incompatible/go.mod h1:nmEj6Dob7S7YxXgwXpfOuvO54S+tGdZdw9fuRZt25Ag= github.com/circonus-labs/circonusllhist v0.1.3/go.mod h1:kMXHVDlOchFAehlya5ePtbp5jckzBHf4XRpQvBOLI+I= github.com/clbanning/mxj v1.8.4/go.mod h1:BVjHeAH+rl9rs6f+QIpeRl0tfu10SXn1pUSa5PVGJng= +github.com/clbanning/x2j v0.0.0-20191024224557-825249438eec/go.mod h1:jMjuTZXRI4dUb/I5gc9Hdhagfvm9+RyrPryS/auMzxE= github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw= github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc= github.com/cncf/udpa/go v0.0.0-20200629203442-efcf912fb354/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= @@ -214,16 +238,23 @@ github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWH github.com/cncf/xds/go v0.0.0-20211130200136-a8f946100490/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= github.com/cockroachdb/apd/v2 v2.0.2 h1:weh8u7Cneje73dDh+2tEVLUvyBc89iwepWCD8b8034E= github.com/cockroachdb/datadriven v0.0.0-20190809214429-80d97fb3cbaa/go.mod h1:zn76sxSg3SzpJ0PPJaLDCu+Bu0Lg3sKTORVIj19EIF8= +github.com/codahale/hdrhistogram v0.0.0-20161010025455-3a0bb77429bd/go.mod h1:sE/e/2PUdi/liOCUjSTXgM1o87ZssimdTWN964YiIeI= github.com/coinbase/rosetta-sdk-go v0.7.9 h1:lqllBjMnazTjIqYrOGv8h8jxjg9+hJazIGZr9ZvoCcA= +github.com/confio/ics23/go v0.6.6/go.mod h1:E45NqnlpxGnpfTWL/xauN7MRwEE28T4Dd4uraToOaKg= github.com/confio/ics23/go v0.7.0 h1:00d2kukk7sPoHWL4zZBZwzxnpA2pec1NPdwbSokJ5w8= github.com/confio/ics23/go v0.7.0/go.mod h1:E45NqnlpxGnpfTWL/xauN7MRwEE28T4Dd4uraToOaKg= +github.com/containerd/console v1.0.2/go.mod h1:ytZPjGgY2oeTkAONYafi2kSj0aYggsf8acV1PGKCbzQ= github.com/containerd/console v1.0.3/go.mod h1:7LqA/THxQ86k76b8c/EMSiaJ3h1eZkMkXar0TQ1gf3U= +github.com/containerd/continuity v0.0.0-20190827140505-75bee3e2ccb6/go.mod h1:GL3xCUCBDV3CZiTSEKksMWbLE66hEyuu9qyDOOqM47Y= github.com/containerd/continuity v0.3.0/go.mod h1:wJEAIwKOm/pBZuBd0JmeTvnLquTB1Ag8espWhkykbPM= +github.com/coreos/bbolt v1.3.2/go.mod h1:iRUV2dpdMOn7Bo10OQBFzIJO9kkE559Wcmn+qkEiiKk= github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE= +github.com/coreos/etcd v3.3.13+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE= github.com/coreos/go-etcd v2.0.0+incompatible/go.mod h1:Jez6KQU2B/sWsbdaef3ED8NzMklzPG4d5KIOhIy30Tk= github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk= github.com/coreos/go-semver v0.3.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk= github.com/coreos/go-systemd v0.0.0-20180511133405-39ca1b05acc7/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4= +github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4= github.com/coreos/go-systemd v0.0.0-20190620071333-e64a0ec8b42a/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4= github.com/coreos/go-systemd/v22 v22.3.2/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc= github.com/coreos/go-systemd/v22 v22.3.3-0.20220203105225-a9a7ef127534/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc= @@ -233,12 +264,13 @@ github.com/cosmos/btcutil v1.0.4 h1:n7C2ngKXo7UC9gNyMNLbzqz7Asuf+7Qv4gnX/rOdQ44= github.com/cosmos/btcutil v1.0.4/go.mod h1:Ffqc8Hn6TJUdDgHBwIZLtrLQC1KdJ9jGJl/TvgUaxbU= github.com/cosmos/cosmos-proto v1.0.0-alpha7 h1:yqYUOHF2jopwZh4dVQp3xgqwftE5/2hkrwIV6vkUbO0= github.com/cosmos/cosmos-proto v1.0.0-alpha7/go.mod h1:dosO4pSAbJF8zWCzCoTWP7nNsjcvSUBQmniFxDg5daw= -github.com/cosmos/cosmos-sdk v0.46.0-rc1 h1:5AxZj0RlhV9uIdbHvOVQZ9nQ4xWSs1UsIog/I60vYh0= -github.com/cosmos/cosmos-sdk v0.46.0-rc1/go.mod h1:x+vWHxKIXItFjtZJAsRYF8YmoFaH8+3+rvQSVuerkjg= +github.com/cosmos/cosmos-sdk v0.46.0-rc2 h1:3bFkg+TYjzns++rNOj+S2P8tfY4xTH79L8BB+Empl3Y= +github.com/cosmos/cosmos-sdk v0.46.0-rc2/go.mod h1:nK39fRb7XB+4X9aJyr3j0Mwp14epBWtrGZ6YXjeY44w= +github.com/cosmos/go-bip39 v0.0.0-20180819234021-555e2067c45d/go.mod h1:tSxLoYXyBmiFeKpvmq4dzayMdCjCnu8uqmCysIGBT2Y= github.com/cosmos/go-bip39 v1.0.0 h1:pcomnQdrdH22njcAatO0yWojsUnCO3y2tNoV1cb6hHY= github.com/cosmos/go-bip39 v1.0.0/go.mod h1:RNJv0H/pOIVgxw6KS7QeX2a0Uo0aKUlfhZ4xuwvCdJw= -github.com/cosmos/iavl v0.18.0 h1:02ur4vnalMR2GuWCFNkuseUcl/BCVmg9tOeHOGiZOkE= -github.com/cosmos/iavl v0.18.0/go.mod h1:L0VZHfq0tqMNJvXlslGExaaiZM7eSm+90Vh9QUbp6j4= +github.com/cosmos/iavl v0.17.3 h1:s2N819a2olOmiauVa0WAhoIJq9EhSXE9HDBAoR9k+8Y= +github.com/cosmos/iavl v0.17.3/go.mod h1:prJoErZFABYZGDHka1R6Oay4z9PrNeFFiMKHDAMOi4w= github.com/cosmos/ledger-cosmos-go v0.11.1 h1:9JIYsGnXP613pb2vPjFeMMjBI5lEDsEaF6oYorTy6J4= github.com/cosmos/ledger-cosmos-go v0.11.1/go.mod h1:J8//BsAGTo3OC/vDLjMRFLW6q0WAaXvHnVc7ZmE8iUY= github.com/cosmos/ledger-go v0.9.2 h1:Nnao/dLwaVTk1Q5U9THldpUMMXU94BOTWPddSmVB6pI= @@ -248,14 +280,10 @@ github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:ma github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU= github.com/cpuguy83/go-md2man/v2 v2.0.1/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= -github.com/creachadair/atomicfile v0.2.6/go.mod h1:BRq8Une6ckFneYXZQ+kO7p1ZZP3I2fzVzf28JxrIkBc= -github.com/creachadair/command v0.0.0-20220426235536-a748effdf6a1/go.mod h1:bAM+qFQb/KwWyCc9MLC4U1jvn3XyakqP5QRkds5T6cY= -github.com/creachadair/taskgroup v0.3.2 h1:zlfutDS+5XG40AOxcHDSThxKzns8Tnr9jnr6VqkYlkM= -github.com/creachadair/taskgroup v0.3.2/go.mod h1:wieWwecHVzsidg2CsUnFinW1faVN4+kq+TDlRJQ0Wbk= -github.com/creachadair/tomledit v0.0.22/go.mod h1:cIu/4x5L855oSRejIqr+WRFh+mv9g4fWLiUFaApYn/Y= github.com/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7DoTY= github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= github.com/creack/pty v1.1.11/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= +github.com/cyphar/filepath-securejoin v0.2.2/go.mod h1:FpkQEhXnPnOthhzymB7CGsFk2G9VLXONKD9G7QGMM+4= github.com/cyphar/filepath-securejoin v0.2.3/go.mod h1:aPGpWjXOXUn2NCNjFvBE6aRxGGx79pTxQpKOJNYHHl4= github.com/daixiang0/gci v0.3.3/go.mod h1:1Xr2bxnQbDxCqqulUOv8qpGqkgRw9RSCGGjEC2LjF8o= github.com/danieljoos/wincred v1.0.2 h1:zf4bhty2iLuwgjgpraD2E9UbvO+fe54XXGJbOwe23fU= @@ -279,6 +307,7 @@ github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZm github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw= github.com/dgryski/go-farm v0.0.0-20200201041132-a6ae2369ad13 h1:fAjc9m62+UWV/WAFKLNi6ZS0675eEUC9y3AlwSbQu1Y= github.com/dgryski/go-farm v0.0.0-20200201041132-a6ae2369ad13/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw= +github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no= github.com/dnaeon/go-vcr v1.2.0/go.mod h1:R4UdLID7HZT3taECzJs4YgbbH6PIGXB6W/sc5OLb6RQ= github.com/docker/cli v20.10.14+incompatible/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8= github.com/docker/cli v20.10.17+incompatible/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8= @@ -295,6 +324,7 @@ github.com/eapache/go-resiliency v1.1.0/go.mod h1:kFI+JgMyC7bLPUVY133qvEBtVayf5m github.com/eapache/go-xerial-snappy v0.0.0-20180814174437-776d5712da21/go.mod h1:+020luEh2TKB4/GOp8oxxtq0Daoen/Cii55CzbTV6DU= github.com/eapache/queue v1.1.0/go.mod h1:6eCeP0CKFpHLu8blIFXhExK/dRa7WDZfr6jVFPTqq+I= github.com/edsrzf/mmap-go v1.0.0/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M= +github.com/envoyproxy/go-control-plane v0.6.9/go.mod h1:SBwIajubJHhxtWwsL9s8ss4safvEdbitLhGGK48rN6g= github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98= @@ -325,7 +355,9 @@ github.com/fatih/structtag v1.2.0/go.mod h1:mBJUNpUnHmRKrKlQQlmCrh5PuhftFbNv8Ys4 github.com/felixge/httpsnoop v1.0.1 h1:lvB5Jl89CsZtGIWuTcDM1E/vkVs49/Ml7JJe07l8SPQ= github.com/firefart/nonamedreturns v1.0.1/go.mod h1:D3dpIBojGGNh5UfElmwPu73SwDCm+VKhHYqwlNOk2uQ= github.com/fogleman/gg v1.2.1-0.20190220221249-0403632d5b90/go.mod h1:R/bRT+9gY/C5z7JzPU0zXsXHKM4/ayA+zqcVNZzPa1k= +github.com/fortytw2/leaktest v1.3.0 h1:u8491cBMTQ8ft8aeV+adlcytMZylmA5nnwwkRZjI8vw= github.com/fortytw2/leaktest v1.3.0/go.mod h1:jDsjWgpAGjm2CA7WthBh/CdZYEPF31XHquHwclZch5g= +github.com/franela/goblin v0.0.0-20200105215937-c9ffbefa60db/go.mod h1:7dvUGVsVBjqR7JHJk0brhHOZYGmfBYOrK0ZhYMEtBr4= github.com/franela/goblin v0.0.0-20210519012713-85d372ac71e2/go.mod h1:VzmDKDJVZI3aJmnRI9VjAn9nJ8qPPsN1fqzr9dqInIo= github.com/franela/goreq v0.0.0-20171204163338-bcd34c9993f8/go.mod h1:ZhphrRTfi2rbfLwlschooIH4+wKKDR4Pdxhh+TRoA20= github.com/frankban/quicktest v1.11.3/go.mod h1:wRf/ReqHper53s+kmmSZizM8NamnL3IM0I9ntUbOk+k= @@ -346,13 +378,17 @@ github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2 github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as= github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as= +github.com/go-kit/kit v0.10.0/go.mod h1:xUsJbQ/Fp4kEt7AFgCuvyX4a71u8h9jB8tj/ORgOZ7o= github.com/go-kit/kit v0.12.0 h1:e4o3o3IsBfAKQh5Qbbiqyfu97Ku7jrO/JbohvztANh4= github.com/go-kit/kit v0.12.0/go.mod h1:lHd+EkCZPIwYItmGDDRdhinkzX2A1sj+M9biaEaizzs= github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY= github.com/go-kit/log v0.2.0/go.mod h1:NwTd00d/i8cPZ3xOwwiv2PO5MOcx78fFErGNcVmBjv0= +github.com/go-kit/log v0.2.1 h1:MRVx0/zhvdseW+Gza6N9rVzU/IVzaeE1SFI4raAhmBU= +github.com/go-kit/log v0.2.1/go.mod h1:NwTd00d/i8cPZ3xOwwiv2PO5MOcx78fFErGNcVmBjv0= github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE= github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk= github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A= +github.com/go-logfmt/logfmt v0.5.1 h1:otpy5pqBCBZ1ng9RQ0dPu4PN7ba75Y/aA+UpowDyNVA= github.com/go-logfmt/logfmt v0.5.1/go.mod h1:WYhtIu8zTZfxdn5+rREduYbwxfcBr/Vr6KEVveWlfTs= github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= github.com/go-redis/redis v6.15.8+incompatible/go.mod h1:NAIEuMOZ/fxfXJIrKDQDz8wamY7mA7PouImQ2Jvg6kA= @@ -378,7 +414,10 @@ github.com/godbus/dbus v0.0.0-20190726142602-4481cbc300e2/go.mod h1:bBOAhwG1umN6 github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= github.com/godbus/dbus/v5 v5.0.6/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= github.com/gofrs/flock v0.8.1/go.mod h1:F1TvTiK9OcQqauNUHlbJvyl9Qa1QvF/gOUDKA14jxHU= +github.com/gofrs/uuid v4.2.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM= github.com/gogo/gateway v1.1.0 h1:u0SuhL9+Il+UbjM9VIE3ntfRujKbvVpFvNB4HbjeVQ0= +github.com/gogo/gateway v1.1.0/go.mod h1:S7rR8FRQyG3QFESeSv4l2WnsyzlCLG0CzBbUUo/mbic= +github.com/gogo/googleapis v1.1.0/go.mod h1:gf4bu3Q80BeJ6H1S1vYPm8/ELATdvryBaNFGgqEef3s= github.com/golang-jwt/jwt/v4 v4.0.0/go.mod h1:/xlHOz8bRuivTWchD4jCa+NbatV+wEUSzwAxVc6locg= github.com/golang-sql/civil v0.0.0-20190719163853-cb61b32ac6fe/go.mod h1:8vg3r2VgvsThLBIFL93Qb5yWzgyZWhEmBwUJWevAkK0= github.com/golang-sql/sqlexp v0.0.0-20170517235910-f1bb20e5a188/go.mod h1:vXjM/+wXQnTPR4KqTKDgJukSZ6amVRtWMPEjE6sQoK8= @@ -387,6 +426,7 @@ github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfU github.com/golang/glog v1.0.0 h1:nfP3RFugxnNRyKgeWd4oI1nYvXpxrx8ck8ZrcizshdQ= github.com/golang/glog v1.0.0/go.mod h1:EWib/APOK0SL3dFbYqvxE3UYd8E6s1ouQ7iEp/0LWV4= github.com/golang/groupcache v0.0.0-20160516000752-02826c3e7903/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/groupcache v0.0.0-20190129154638-5b532d6fd5ef/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= @@ -431,7 +471,7 @@ github.com/golangci/check v0.0.0-20180506172741-cfe4005ccda2/go.mod h1:k9Qvh+8ju github.com/golangci/dupl v0.0.0-20180902072040-3e9179ac440a/go.mod h1:ryS0uhF+x9jgbj/N71xsEqODy9BN81/GonCZiOzirOk= github.com/golangci/go-misc v0.0.0-20220329215616-d24fe342adfe/go.mod h1:gjqyPShc/m8pEMpk0a3SeagVb0kaqvhscv+i9jI5ZhQ= github.com/golangci/gofmt v0.0.0-20190930125516-244bba706f1a/go.mod h1:9qCChq59u/eW8im404Q2WWTrnBUQKjpNYKMbU4M7EFU= -github.com/golangci/golangci-lint v1.46.0/go.mod h1:IJpcNOUfx/XLRwE95FHQ6QtbhYwwqcm0H5QkwUfF4ZE= +github.com/golangci/golangci-lint v1.46.2/go.mod h1:3DkdHnxn9eoTTrpT2gB0TEv8KSziuoqe9FitgQLHvAY= github.com/golangci/lint-1 v0.0.0-20191013205115-297bf364a8e0/go.mod h1:66R6K6P6VWk9I95jvqGxkqJxVWGFy9XlDwLwVz1RCFg= github.com/golangci/maligned v0.0.0-20180506175553-b1d89398deca/go.mod h1:tvlJhZqDe4LMs4ZHD0oMUlt9G2LWuDGoisJTBzLMV9o= github.com/golangci/misspell v0.3.5/go.mod h1:dEbvlSfYbMQDtrpRMQU675gSDLDNa8sCPPChZ7PhiVA= @@ -493,7 +533,6 @@ github.com/google/uuid v0.0.0-20161128191214-064e2069ce9c/go.mod h1:TIyPZe4Mgqvf github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I= github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg= github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk= @@ -512,10 +551,12 @@ github.com/gorhill/cronexpr v0.0.0-20180427100037-88b0669f7d75/go.mod h1:g2644b0 github.com/gorilla/context v1.1.1/go.mod h1:kBGZzfjB9CEq2AlWe17Uuf7NDRt0dE0s8S51q0aT7Yg= github.com/gorilla/handlers v1.5.1 h1:9lRY6j8DEeeBT10CvO9hGW0gmky0BprnvDI5vfhUHH4= github.com/gorilla/mux v1.6.2/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs= +github.com/gorilla/mux v1.7.3/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs= github.com/gorilla/mux v1.8.0 h1:i40aqfkR1h2SlN9hojwV5ZA91wcXFOvkdNIeFDP5koI= github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So= github.com/gorilla/websocket v0.0.0-20170926233335-4201258b820c/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ= github.com/gorilla/websocket v1.4.1/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= +github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc= github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= github.com/gostaticanalysis/analysisutil v0.0.0-20190318220348-4088753ea4d3/go.mod h1:eEOZF4jCKGi+aprrirO9e7WKB3beBRtWgqGunKl6pKE= @@ -532,21 +573,32 @@ github.com/gostaticanalysis/testutil v0.3.1-0.20210208050101-bfb5c8eec0e4/go.mod github.com/gostaticanalysis/testutil v0.4.0/go.mod h1:bLIoPefWXrRi/ssLFWX1dx7Repi5x3CuviD3dgAZaBU= github.com/gotestyourself/gotestyourself v2.2.0+incompatible/go.mod h1:zZKM6oeNM8k+FRljX1mnzVYeS8wiGgQyvST1/GafPbY= github.com/gregjones/httpcache v0.0.0-20190611155906-901d90724c79/go.mod h1:FecbI9+v66THATjSRHfNgh1IVFe/9kFxbXtjV0ctIMA= +github.com/grpc-ecosystem/go-grpc-middleware v1.0.0/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs= github.com/grpc-ecosystem/go-grpc-middleware v1.0.1-0.20190118093823-f849b5445de4/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs= github.com/grpc-ecosystem/go-grpc-middleware v1.2.2/go.mod h1:EaizFBKfUKtMIF5iaDEhniwNedqGo9FuLFzppDr3uwI= github.com/grpc-ecosystem/go-grpc-middleware v1.3.0 h1:+9834+KizmvFV7pXQGSXQTsaWhq2GjuNUt0aUU0YBYw= github.com/grpc-ecosystem/go-grpc-middleware v1.3.0/go.mod h1:z0ButlSOZa5vEBq9m2m2hlwIgKw+rp3sdCBRoJY+30Y= -github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0 h1:Ovs26xHkKqVztRpIrF/92BcuyuQ/YW4NSIpoGtfXNho= github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk= +github.com/grpc-ecosystem/grpc-gateway v1.8.5/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY= +github.com/grpc-ecosystem/grpc-gateway v1.9.0/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY= github.com/grpc-ecosystem/grpc-gateway v1.9.5/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY= github.com/grpc-ecosystem/grpc-gateway v1.12.1/go.mod h1:8XEsbTttt/W+VvjtQhLACqCisSPWTxCZ7sBRjU6iH9c= github.com/grpc-ecosystem/grpc-gateway v1.16.0 h1:gmcG1KaJ57LophUzW0Hy8NmPhnMZb4M0+kPpLofRdBo= github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw= github.com/gsterjov/go-libsecret v0.0.0-20161001094733-a6f4afe4910c h1:6rhixN/i8ZofjG1Y75iExal34USq5p+wiN1tpie8IrU= github.com/gsterjov/go-libsecret v0.0.0-20161001094733-a6f4afe4910c/go.mod h1:NMPJylDgVpX0MLRlPy15sqSwOFv/U1GZ2m21JhFfek0= +github.com/gtank/merlin v0.1.1-0.20191105220539-8318aed1a79f/go.mod h1:T86dnYJhcGOh5BjZFCJWTDeTK7XW8uE+E21Cy/bIQ+s= +github.com/gtank/merlin v0.1.1 h1:eQ90iG7K9pOhtereWsmyRJ6RAwcP4tHTDBHXNg+u5is= +github.com/gtank/merlin v0.1.1/go.mod h1:T86dnYJhcGOh5BjZFCJWTDeTK7XW8uE+E21Cy/bIQ+s= +github.com/gtank/ristretto255 v0.1.2 h1:JEqUCPA1NvLq5DwYtuzigd7ss8fwbYay9fi4/5uMzcc= +github.com/gtank/ristretto255 v0.1.2/go.mod h1:Ph5OpO6c7xKUGROZfWVLiJf9icMDwUeIvY4OmlYW69o= +github.com/hashicorp/consul/api v1.1.0/go.mod h1:VmuI/Lkw1nC05EYQWNKwWGbkg+FbDBtguAZLlVdkD9Q= +github.com/hashicorp/consul/api v1.3.0/go.mod h1:MmDNSzIMUjNpY/mQ398R4bk2FnqQLoPndWW5VkKPlCE= github.com/hashicorp/consul/api v1.10.1/go.mod h1:XjsvQN+RJGWI2TWy1/kqaE16HrR2J/FWgkYjdZQsX9M= github.com/hashicorp/consul/api v1.11.0/go.mod h1:XjsvQN+RJGWI2TWy1/kqaE16HrR2J/FWgkYjdZQsX9M= github.com/hashicorp/consul/api v1.12.0/go.mod h1:6pVBMo0ebnYdt2S3H87XhekM/HHrUoTD2XXb/VrZVy0= +github.com/hashicorp/consul/sdk v0.1.1/go.mod h1:VKf9jXwCTEY1QZP2MOLRhb5i/I/ssyNV1vwHyQBF0x8= +github.com/hashicorp/consul/sdk v0.3.0/go.mod h1:VKf9jXwCTEY1QZP2MOLRhb5i/I/ssyNV1vwHyQBF0x8= github.com/hashicorp/consul/sdk v0.8.0/go.mod h1:GBvyrGALthsZObzUGsfgHZQDXjg4lOjagTIwIR1vPms= github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= github.com/hashicorp/go-cleanhttp v0.5.0/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80= @@ -567,6 +619,7 @@ github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHh github.com/hashicorp/go-multierror v1.1.0/go.mod h1:spPvp8C1qA32ftKqdAHm4hHTbPw+vmowP0z+KUhOZdA= github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM= github.com/hashicorp/go-retryablehttp v0.5.3/go.mod h1:9B5zBasrRhHXnJnui7y6sL7es7NDiJgTc6Er0maI1Xs= +github.com/hashicorp/go-rootcerts v1.0.0/go.mod h1:K6zTfqpRlCUIjkwsN4Z+hiSfzSTQa6eBIzfwKfwNnHU= github.com/hashicorp/go-rootcerts v1.0.2/go.mod h1:pqUvnprVnM5bf7AOirdbb01K4ccR319Vf4pU3K5EGc8= github.com/hashicorp/go-safetemp v1.0.0 h1:2HR189eFNrjHQyENnQMMpCiBAsRxzbTMIgBhEyExpmo= github.com/hashicorp/go-safetemp v1.0.0/go.mod h1:oaerMy3BhqiTbVye6QuFhFtIceqFoDHxNAB65b+Rj1I= @@ -576,9 +629,11 @@ github.com/hashicorp/go-uuid v1.0.0/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/b github.com/hashicorp/go-uuid v1.0.1 h1:fv1ep09latC32wFoVwnqcnKJGnMSdBanPczbHAYm1BE= github.com/hashicorp/go-uuid v1.0.1/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro= github.com/hashicorp/go-version v1.1.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA= +github.com/hashicorp/go-version v1.2.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA= github.com/hashicorp/go-version v1.2.1/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA= github.com/hashicorp/go-version v1.4.0 h1:aAQzgqIrRKRa7w75CKpbBxYsmUoPjzVm1W59ca1L0J4= github.com/hashicorp/go-version v1.4.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA= +github.com/hashicorp/go.net v0.0.1/go.mod h1:hjKkEWcCURg++eb33jQU7oqQcI9XDCnUzHA0oac0k90= github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= github.com/hashicorp/golang-lru v0.5.4/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4= @@ -587,10 +642,13 @@ github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d/go.mod h1:i github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4= github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ= github.com/hashicorp/logutils v1.0.0/go.mod h1:QIAnNjmIWmVIIkWDTG1z5v++HQmx9WQRO+LraFDTW64= +github.com/hashicorp/mdns v1.0.0/go.mod h1:tL+uN++7HEJ6SQLQ2/p+z2pH24WQKWjBPkE0mNTz8vQ= github.com/hashicorp/mdns v1.0.1/go.mod h1:4gW7WsVCke5TE7EPeYliwHlRUyBtfCwuFwuMg2DmyNY= github.com/hashicorp/mdns v1.0.4/go.mod h1:mtBihi+LeNXGtG8L9dX59gAEa12BDtBQSp4v/YAJqrc= +github.com/hashicorp/memberlist v0.1.3/go.mod h1:ajVTdAv/9Im8oMAAj5G31PhhMCZJV2pPBoIllUwCN7I= github.com/hashicorp/memberlist v0.2.2/go.mod h1:MS2lj3INKhZjWNqd3N0m3J+Jxf3DAOnAH9VT3Sh9MUE= github.com/hashicorp/memberlist v0.3.0/go.mod h1:MS2lj3INKhZjWNqd3N0m3J+Jxf3DAOnAH9VT3Sh9MUE= +github.com/hashicorp/serf v0.8.2/go.mod h1:6hOLApaqBFA1NXqRQAsxw9QxuDEvNxSQRwA/JwenrHc= github.com/hashicorp/serf v0.9.5/go.mod h1:UWDWwZeL5cuWDJdl0C6wrvrUwEqtQ4ZKBKKENpqIUyk= github.com/hashicorp/serf v0.9.6/go.mod h1:TXZNMjZQijwlDvp+r0b63xZ45H7JmCmgg4gpTwn9UV4= github.com/hashicorp/serf v0.9.7/go.mod h1:TXZNMjZQijwlDvp+r0b63xZ45H7JmCmgg4gpTwn9UV4= @@ -600,6 +658,7 @@ github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSo github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= github.com/huandu/xstrings v1.0.0/go.mod h1:4qWG/gcEcfX4z/mBDHJ++3ReCw9ibxbsNJbcucJdbSo= github.com/huandu/xstrings v1.2.0/go.mod h1:DvyZB1rfVYsBIigL8HwpZgxHwXozlTgGqn63UyNX5k4= +github.com/hudl/fargo v1.3.0/go.mod h1:y3CKSmjA+wD2gak7sUSXTAoopbhU08POFhmITJgmKTg= github.com/hudl/fargo v1.4.0/go.mod h1:9Ai6uvFy5fQNq6VPKtg+Ceq1+eTY4nKUlR2JElEOcDo= github.com/iancoleman/strcase v0.2.0/go.mod h1:iwCmte+B7n89clKwxIoIXy/HfoL7AsD47ZCWhYzw7ho= github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= @@ -611,11 +670,19 @@ github.com/imdario/mergo v0.3.13/go.mod h1:4lJ1jqUDcsbIECGy0RUJAXNIhg+6ocWgb1ALK github.com/improbable-eng/grpc-web v0.15.0 h1:BN+7z6uNXZ1tQGcNAuaU1YjsLTApzkjt2tzCixLaUPQ= github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM= github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8= +github.com/influxdata/influxdb1-client v0.0.0-20191209144304-8bf82d3c094d/go.mod h1:qj24IKcXYK6Iy9ceXlo3Tc+vtHo9lIhSX5JddghvEPo= github.com/influxdata/influxdb1-client v0.0.0-20200827194710-b269163b24ab/go.mod h1:qj24IKcXYK6Iy9ceXlo3Tc+vtHo9lIhSX5JddghvEPo= +github.com/jdxcode/netrc v0.0.0-20210204082910-926c7f70242a/go.mod h1:Zi/ZFkEqFHTm7qkjyNJjaWH4LQA9LQhGJyF0lTYGpxw= github.com/jessevdk/go-flags v0.0.0-20141203071132-1679536dcc89/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI= github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI= github.com/jgautheron/goconst v1.5.1/go.mod h1:aAosetZ5zaeC/2EfMeRswtxUFBpe2Hr7HzkgX4fanO4= +github.com/jhump/gopoet v0.0.0-20190322174617-17282ff210b3/go.mod h1:me9yfT6IJSlOL3FCfrg+L6yzUEZ+5jW6WHt4Sk+UPUI= +github.com/jhump/gopoet v0.1.0/go.mod h1:me9yfT6IJSlOL3FCfrg+L6yzUEZ+5jW6WHt4Sk+UPUI= +github.com/jhump/goprotoc v0.5.0/go.mod h1:VrbvcYrQOrTi3i0Vf+m+oqQWk9l72mjkJCYo7UvLHRQ= +github.com/jhump/protocompile v0.0.0-20220216033700-d705409f108f/go.mod h1:qr2b5kx4HbFS7/g4uYO5qv9ei8303JMsC7ESbYiqr2Q= github.com/jhump/protoreflect v1.6.1/go.mod h1:RZQ/lnuN+zqeRVpQigTwO6o0AJUkxbnSnpuG7toUTG4= +github.com/jhump/protoreflect v1.11.0/go.mod h1:U7aMIjN0NWq9swDP7xDdoMfRHb35uiuTd3Z9nFXJf5E= +github.com/jhump/protoreflect v1.12.1-0.20220417024638-438db461d753/go.mod h1:JytZfP5d0r8pVNLZvai7U/MCuTWITgrI4tTg7puQFKI= github.com/jingyugao/rowserrcheck v1.1.1/go.mod h1:4yvlZSDb3IyDTUZJUmpZfm2Hwok+Dtp+nu2qOq+er9c= github.com/jirfag/go-printf-func-name v0.0.0-20200119135958-7558a9eaa5af/go.mod h1:HEWGJkRDzjJY2sqdDwxccsGicWEf9BQOZsq2tV+xzM0= github.com/jmespath/go-jmespath v0.0.0-20160202185014-0b12d6b521d8/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k= @@ -634,6 +701,7 @@ github.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX github.com/jrick/logrotate v1.0.0/go.mod h1:LNinyqDIJnpAur+b8yyulnQw/wDuN1+BYKlTRt3OuAQ= github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU= github.com/json-iterator/go v1.1.7/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= +github.com/json-iterator/go v1.1.8/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= github.com/json-iterator/go v1.1.11/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= @@ -657,8 +725,10 @@ github.com/klauspost/compress v1.11.2/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYs github.com/klauspost/compress v1.12.3/go.mod h1:8dP1Hq4DHOhN9w426knH3Rhby4rFm6D8eO+e+Dq5Gzg= github.com/klauspost/compress v1.13.4/go.mod h1:8dP1Hq4DHOhN9w426knH3Rhby4rFm6D8eO+e+Dq5Gzg= github.com/klauspost/compress v1.13.5/go.mod h1:/3/Vjq9QcHkK5uEr5lBEmyoZ1iFhe47etQ6QUkpK6sk= -github.com/klauspost/compress v1.13.6 h1:P76CopJELS0TiO2mebmnzgWaajssP/EszplttgQxcgc= github.com/klauspost/compress v1.13.6/go.mod h1:/3/Vjq9QcHkK5uEr5lBEmyoZ1iFhe47etQ6QUkpK6sk= +github.com/klauspost/compress v1.15.1 h1:y9FcTHGyrebwfP0ZZqFiaxTaiDnUrGkJkI+f583BL1A= +github.com/klauspost/compress v1.15.1/go.mod h1:/3/Vjq9QcHkK5uEr5lBEmyoZ1iFhe47etQ6QUkpK6sk= +github.com/klauspost/pgzip v1.2.5/go.mod h1:Ch1tH69qFZu15pkjo5kYi6mth2Zzwzt50oCQKQE9RUs= github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= github.com/konsorten/go-windows-terminal-sequences v1.0.2/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= @@ -683,6 +753,7 @@ github.com/leonklingele/grouper v1.1.0/go.mod h1:uk3I3uDfi9B6PeUjsCKi6ndcf63Uy7s github.com/letsencrypt/pkcs11key/v4 v4.0.0/go.mod h1:EFUvBDay26dErnNb70Nd0/VW3tJiIbETBPTl9ATXQag= github.com/lib/pq v0.0.0-20180327071824-d34b9ff171c2/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo= github.com/lib/pq v1.0.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo= +github.com/lib/pq v1.2.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo= github.com/lib/pq v1.8.0/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o= github.com/lib/pq v1.9.0/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o= github.com/lib/pq v1.10.4/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o= @@ -690,10 +761,14 @@ github.com/lib/pq v1.10.6 h1:jbk+ZieJ0D7EVGJYpL9QTz7/YW6UHbmdnZWYyK5cdBs= github.com/lib/pq v1.10.6/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o= github.com/libp2p/go-buffer-pool v0.0.2 h1:QNK2iAFa8gjAe1SPz6mHSMuCcjs+X1wlHzeOSqcmlfs= github.com/libp2p/go-buffer-pool v0.0.2/go.mod h1:MvaB6xw5vOrDl8rYZGLFdKAuk/hRoRZd1Vi32+RXyFM= -github.com/lufeee/execinquery v1.0.0/go.mod h1:EC7DrEKView09ocscGHC+apXMIaorh4xqSxS/dy8SbM= +github.com/lightstep/lightstep-tracer-common/golang/gogo v0.0.0-20190605223551-bc2310a04743/go.mod h1:qklhhLq1aX+mtWk9cPHPzaBjWImj5ULL6C7HFJtXQMM= +github.com/lightstep/lightstep-tracer-go v0.18.1/go.mod h1:jlF1pusYV4pidLvZ+XD0UBX0ZE6WURAspgAczcDHrL4= +github.com/lufeee/execinquery v1.2.1/go.mod h1:EC7DrEKView09ocscGHC+apXMIaorh4xqSxS/dy8SbM= github.com/lufia/plan9stats v0.0.0-20211012122336-39d0f177ccd0/go.mod h1:zJYVVT2jmtg6P3p1VtQj7WsuWi/y4VnjVBn7F8KPB3I= github.com/lyft/protoc-gen-star v0.5.3/go.mod h1:V0xaHgaf5oCCqmcxYcWiDfTiKsZsRc87/1qhoTACD8w= +github.com/lyft/protoc-gen-validate v0.0.13/go.mod h1:XbGvPuh87YZc5TdIa2/I4pLk0QoUACkjt2znoq26NVQ= github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ= +github.com/magiconair/properties v1.8.1/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ= github.com/magiconair/properties v1.8.5/go.mod h1:y3VJvCyxH9uVvJTWEGAELF3aiYNyPKd5NZ3oSwXrF60= github.com/magiconair/properties v1.8.6 h1:5ibWZ6iY0NctNGWo87LalDlEZ6R41TqbbDamhfG/Qzo= github.com/magiconair/properties v1.8.6/go.mod h1:y3VJvCyxH9uVvJTWEGAELF3aiYNyPKd5NZ3oSwXrF60= @@ -733,9 +808,12 @@ github.com/miekg/dns v1.1.41/go.mod h1:p6aan82bvRIyn+zDIv9xYNUpwa73JcSh9BKwknJys github.com/miekg/dns v1.1.43/go.mod h1:+evo5L0630/F6ca/Z9+GAqzhjGyn8/c+TBaOyfEl0V4= github.com/miekg/pkcs11 v1.0.2/go.mod h1:XsNlhZGX73bx86s2hdc/FuaLm2CPZJemRLMA+WTFxgs= github.com/miekg/pkcs11 v1.0.3/go.mod h1:XsNlhZGX73bx86s2hdc/FuaLm2CPZJemRLMA+WTFxgs= +github.com/mimoo/StrobeGo v0.0.0-20181016162300-f8f6d4d2b643 h1:hLDRPB66XQT/8+wG9WsDpiCvZf1yKO7sz7scAjSlBa0= +github.com/mimoo/StrobeGo v0.0.0-20181016162300-f8f6d4d2b643/go.mod h1:43+3pMjjKimDBf5Kr4ZFNGbLql1zKkbImw+fZbw3geM= github.com/minio/highwayhash v1.0.1/go.mod h1:BQskDq+xkJ12lmlUUi7U0M5Swg3EWR+dLTk+kldvVxY= github.com/minio/highwayhash v1.0.2 h1:Aak5U0nElisjDCfPSG79Tgzkn2gl66NxOMspRrKnA/g= github.com/minio/highwayhash v1.0.2/go.mod h1:BQskDq+xkJ12lmlUUi7U0M5Swg3EWR+dLTk+kldvVxY= +github.com/mitchellh/cli v1.0.0/go.mod h1:hNIlj7HEI86fIcpObd7a0FcrxTWetlwJDGcceTlRvqc= github.com/mitchellh/cli v1.1.0/go.mod h1:xcISNoH86gajksDmfB23e/pu+B+GeFRMYmoHXxx3xhI= github.com/mitchellh/copystructure v1.0.0/go.mod h1:SNtv71yrdKgLRyLFxmLdkAbkKEFWgYaq1OVrnRcwhnw= github.com/mitchellh/go-homedir v1.0.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0= @@ -744,6 +822,8 @@ github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrk github.com/mitchellh/go-ps v1.0.0/go.mod h1:J4lOc8z8yJs6vUwklHw2XEIiT4z4C40KtWVN3nvg8Pg= github.com/mitchellh/go-testing-interface v1.0.0 h1:fzU/JVNcaqHQEcVFAKeR41fkiLdIPrefOvVG1VZ96U0= github.com/mitchellh/go-testing-interface v1.0.0/go.mod h1:kRemZodwjscx+RGhAo8eIhFbs2+BFgRtFPeD/KE+zxI= +github.com/mitchellh/gox v0.4.0/go.mod h1:Sd9lOJ0+aimLBi73mGofS1ycjY8lL3uZM3JPS42BGNg= +github.com/mitchellh/iochan v1.0.0/go.mod h1:JwYml1nuB7xOzsp52dPpHFffvOCDupsG0QubkSMEySY= github.com/mitchellh/mapstructure v0.0.0-20160808181253-ca63d7c062ee/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y= github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y= github.com/mitchellh/mapstructure v1.4.1/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= @@ -753,6 +833,7 @@ github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyua github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= github.com/mitchellh/reflectwalk v1.0.0/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw= github.com/mitchellh/reflectwalk v1.0.1/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw= +github.com/moby/sys/mountinfo v0.4.1/go.mod h1:rEr8tzG/lsIZHBtN/JjGG+LMYx9eXgW2JI+6q0qou+A= github.com/moby/sys/mountinfo v0.5.0/go.mod h1:3bMD3Rg+zkqx8MRYPi7Pyb0Ie97QEBmdxbhnCLlSvSU= github.com/moby/term v0.0.0-20201216013528-df9cb8a40635/go.mod h1:FBS0z0QWA44HXygs7VXDUOGoN/1TV3RuWkLO04am3wc= github.com/moby/term v0.0.0-20210619224110-3f7ff695adc6/go.mod h1:E2VnQOmVuvZB6UYnnDB0qG5Nq/1tD9acaOpo6xmt0Kw= @@ -766,7 +847,6 @@ github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826/go.mod h1:TaXosZuwd github.com/moricho/tparallel v0.2.1/go.mod h1:fXEIZxG2vdfl0ZF8b42f5a78EhjjD5mX8qUplsoSU4k= github.com/mozilla/scribe v0.0.0-20180711195314-fb71baf557c1/go.mod h1:FIczTrinKo8VaLxe6PWTPEXRXDIHz2QAwiaBaP5/4a8= github.com/mozilla/tls-observatory v0.0.0-20210609171429-7bc42856d2e5/go.mod h1:FUqVoUPHSEdDR0MnFM3Dh8AU0pZHLXUD127SAJGER/s= -github.com/mroth/weightedrand v0.4.1/go.mod h1:3p2SIcC8al1YMzGhAIoXD+r9olo/g/cdJgAD905gyNE= github.com/mrunalp/fileutils v0.5.0/go.mod h1:M1WthSahJixYnrXQl/DFQuteStB1weuxD2QJNHXfbSQ= github.com/mtibben/percent v0.2.1 h1:5gssi8Nqo8QU/r2pynCm+hBQHpkB/uNK7BJCFogWdzs= github.com/mtibben/percent v0.2.1/go.mod h1:KG9uO+SZkUp+VkRHsCdYQV3XSZrrSpR3O9ibNBTZrns= @@ -775,10 +855,16 @@ github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f/go.mod h1:qRW github.com/mwitkow/go-proto-validators v0.0.0-20180403085117-0950a7990007/go.mod h1:m2XC9Qq0AlmmVksL6FktJCdTYyLk7V3fKyp0sl1yWQo= github.com/mwitkow/go-proto-validators v0.2.0/go.mod h1:ZfA1hW+UH/2ZHOWvQ3HnQaU0DtnpXu850MZiy+YUgcc= github.com/nakabonne/nestif v0.3.1/go.mod h1:9EtoZochLn5iUprVDmDjqGKPofoUEBL8U4Ngq6aY7OE= +github.com/nats-io/jwt v0.3.0/go.mod h1:fRYCDE99xlTsqUzISS1Bi75UBJ6ljOJQOAAu5VglpSg= +github.com/nats-io/jwt v0.3.2/go.mod h1:/euKqTS1ZD+zzjYrY7pseZrTtWQSjujC7xjPc8wL6eU= github.com/nats-io/jwt v1.2.2/go.mod h1:/xX356yQA6LuXI9xWW7mZNpxgF2mBmGecH+Fj34sP5Q= github.com/nats-io/jwt/v2 v2.0.3/go.mod h1:VRP+deawSXyhNjXmxPCHskrR6Mq50BqpEI5SEcNiGlY= +github.com/nats-io/nats-server/v2 v2.1.2/go.mod h1:Afk+wRZqkMQs/p45uXdrVLuab3gwv3Z8C4HTBu8GD/k= github.com/nats-io/nats-server/v2 v2.5.0/go.mod h1:Kj86UtrXAL6LwYRA6H4RqzkHhK0Vcv2ZnKD5WbQ1t3g= +github.com/nats-io/nats.go v1.9.1/go.mod h1:ZjDU1L/7fJ09jvUSRVBR2e7+RnLiiIQyqyzEE/Zbp4w= github.com/nats-io/nats.go v1.12.1/go.mod h1:BPko4oXsySz4aSWeFgOHLZs3G4Jq4ZAyE6/zMCxRT6w= +github.com/nats-io/nkeys v0.1.0/go.mod h1:xpnFELMwJABBLVhffcfd1MZx6VsNRFpEugbxziKVo7w= +github.com/nats-io/nkeys v0.1.3/go.mod h1:xpnFELMwJABBLVhffcfd1MZx6VsNRFpEugbxziKVo7w= github.com/nats-io/nkeys v0.2.0/go.mod h1:XdZpAbhgyyODYqjTawOnIOI7VlbKSarI9Gfy1tqEu/s= github.com/nats-io/nkeys v0.3.0/go.mod h1:gvUNGjVcM2IPr5rCsRsC6Wb3Hr2CQAm08dsxtV6A5y4= github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c= @@ -791,8 +877,10 @@ github.com/nishanths/predeclared v0.2.2/go.mod h1:RROzoN6TnGQupbC+lqggsOlcgysk3L github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A= github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE= github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU= -github.com/oasisprotocol/curve25519-voi v0.0.0-20210609091139-0a56a4bca00b h1:MKwruh+HeCSKWphkxuzvRzU4QzDkg7yiPkDVV0cDFgI= -github.com/oasisprotocol/curve25519-voi v0.0.0-20210609091139-0a56a4bca00b/go.mod h1:TLJifjWF6eotcfzDjKZsDqWJ+73Uvj/N85MvVyrvynM= +github.com/oklog/oklog v0.3.2/go.mod h1:FCV+B7mhrz4o+ueLpx+KqkyXRGMWOYEvfiXtdGtbWGs= +github.com/oklog/run v1.0.0/go.mod h1:dlhp/R75TPv97u0XWUtDeV/lRKWPKSdTuV0TZvrmrQA= +github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U= +github.com/oklog/ulid/v2 v2.0.2/go.mod h1:mtBL0Qe/0HAx6/a4Z30qxVIAL1eQDweXq5lxOEiwQ68= github.com/olekukonko/tablewriter v0.0.0-20170122224234-a0225b3f23b5/go.mod h1:vsDQFd/mU46D+Z4whnwzcISnGGzXWMclvtLoiIKAKIo= github.com/olekukonko/tablewriter v0.0.1/go.mod h1:vsDQFd/mU46D+Z4whnwzcISnGGzXWMclvtLoiIKAKIo= github.com/olekukonko/tablewriter v0.0.2/go.mod h1:rSAaSIOAGT9odnlyGlUfAJaoc5w2fSBUmeGDbRWPxyQ= @@ -816,14 +904,26 @@ github.com/onsi/gomega v1.17.0/go.mod h1:HnhC7FXeEQY45zxNK3PPoIUhzk/80Xly9PcubAl github.com/onsi/gomega v1.18.1 h1:M1GfJqGRrBrrGGsbxzV5dqM2U2ApXefZCQpkukxYRLE= github.com/onsi/gomega v1.18.1/go.mod h1:0q+aL8jAiMXy9hbwj2mr5GziHiwhAIQpFmmtT5hitRs= github.com/op/go-logging v0.0.0-20160315200505-970db520ece7/go.mod h1:HzydrMdWErDVzsI23lYNej1Htcns9BCg93Dk0bBINWk= +github.com/opencontainers/go-digest v1.0.0-rc1/go.mod h1:cMLVZDEM3+U2I4VmLI6N8jQYUd2OVphdqWwCJHrFt2s= github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM= +github.com/opencontainers/image-spec v1.0.1/go.mod h1:BtxoFyWECRxE4U/7sNtV5W15zMzWCbyJoFRP3s7yZA0= github.com/opencontainers/image-spec v1.0.2/go.mod h1:BtxoFyWECRxE4U/7sNtV5W15zMzWCbyJoFRP3s7yZA0= +github.com/opencontainers/runc v0.1.1/go.mod h1:qT5XzbpPznkRYVz/mWwUaVBUv2rmF59PVA73FjuZG0U= +github.com/opencontainers/runc v1.0.2/go.mod h1:aTaHFFwQXuA71CiyxOdFFIorAoemI04suvGRQFzWTD0= github.com/opencontainers/runc v1.1.2/go.mod h1:Tj1hFw6eFWp/o33uxGf5yF2BX5yz2Z6iptFpuvbbKqc= github.com/opencontainers/runc v1.1.3/go.mod h1:1J5XiS+vdZ3wCyZybsuxXZWGrgSr8fFJHLXuG2PsnNg= github.com/opencontainers/runtime-spec v1.0.3-0.20210326190908-1c3f411f0417/go.mod h1:jwyrGlmzljRJv/Fgzds9SsS/C5hL+LL3ko9hs6T5lQ0= +github.com/opencontainers/selinux v1.8.2/go.mod h1:MUIHuUEvKB1wtJjQdOyYRgOnLD2xAPP8dBsCoU0KuF8= github.com/opencontainers/selinux v1.10.0/go.mod h1:2i0OySw99QjzBBQByd1Gr9gSjvuho1lHsJxIJ3gGbJI= +github.com/opentracing-contrib/go-observer v0.0.0-20170622124052-a52f23424492/go.mod h1:Ngi6UdF0k5OKD5t5wlmGhe/EDKPoUM3BXZSSfIuJbis= +github.com/opentracing/basictracer-go v1.0.0/go.mod h1:QfBfYuafItcjQuMwinw9GhYKwFXS9KnPs5lxoYwgW74= +github.com/opentracing/opentracing-go v1.0.2/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o= github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o= github.com/opentracing/opentracing-go v1.2.0/go.mod h1:GxEUsuufX4nBwe+T+Wl9TAgYrxe9dPLANfrWvHYVTgc= +github.com/openzipkin-contrib/zipkin-go-opentracing v0.4.5/go.mod h1:/wsWhb9smxSfWAKL3wpBW7V8scJMt8N8gnaMCS9E/cA= +github.com/openzipkin/zipkin-go v0.1.6/go.mod h1:QgAqvLzwWbR/WpD4A3cGpPtJrZXNIiJc5AZX7/PBEpw= +github.com/openzipkin/zipkin-go v0.2.1/go.mod h1:NaW6tEwdmWMaCDZzg8sh+IBNOxHMPnhQw8ySjnjRyN4= +github.com/openzipkin/zipkin-go v0.2.2/go.mod h1:NaW6tEwdmWMaCDZzg8sh+IBNOxHMPnhQw8ySjnjRyN4= github.com/openzipkin/zipkin-go v0.2.5/go.mod h1:KpXfKdgRDnnhsxw4pNIH9Md5lyFqKUa4YDFlwRYAMyE= github.com/ory/dockertest v3.3.5+incompatible/go.mod h1:1vX4m9wsvi00u5bseYwXaSnhNrne+V0E6LAcBILJdPs= github.com/ory/dockertest/v3 v3.9.1/go.mod h1:42Ir9hmvaAPm0Mgibk6mBPi7SFvTXxEcnztDYOJ//uM= @@ -836,9 +936,12 @@ github.com/otiai10/mint v1.3.0/go.mod h1:F5AjcsTsWUqX+Na9fpHb52P8pcRX2CI6A3ctIT9 github.com/otiai10/mint v1.3.1/go.mod h1:/yxELlJQ0ufhjUwhshSj+wFjZ78CnZ48/1wtmBH1OTc= github.com/otiai10/mint v1.3.3 h1:7JgpsBaN0uMkyju4tbYHu0mnM55hNKVYLsXmwr15NQI= github.com/otiai10/mint v1.3.3/go.mod h1:/yxELlJQ0ufhjUwhshSj+wFjZ78CnZ48/1wtmBH1OTc= +github.com/pact-foundation/pact-go v1.0.4/go.mod h1:uExwJY4kCzNPcHRj+hCR/HBbOOIwwtUjcrb0b5/5kLM= github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc= github.com/pascaldekloe/goe v0.1.0 h1:cBOtyMzM9HTpWjXfbbunk26uA6nG3a8n06Wieeh0MwY= github.com/pascaldekloe/goe v0.1.0/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc= +github.com/pborman/getopt v0.0.0-20170112200414-7148bc3a4c30/go.mod h1:85jBQOZwpVEaDAr341tbn15RS4fCAsIst0qp7i8ex1o= +github.com/pborman/uuid v1.2.0/go.mod h1:X/NO0urCmaxf9VXbdlT7C2Yzkj2IKimNn4k+gtPdI/k= github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic= github.com/pelletier/go-toml v1.9.4/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCkoOuaOx1Y+c= github.com/pelletier/go-toml v1.9.5 h1:4yBQzkHv+7BHq2PQUZF3Mx0IYxG7LsP222s7Agd3ve8= @@ -848,6 +951,7 @@ github.com/pelletier/go-toml/v2 v2.0.0/go.mod h1:r9LEWfGN8R5k0VXJ+0BkIe7MYkRdwZO github.com/pelletier/go-toml/v2 v2.0.1/go.mod h1:r9LEWfGN8R5k0VXJ+0BkIe7MYkRdwZOjgMj2KwnJFUo= github.com/pelletier/go-toml/v2 v2.0.2 h1:+jQXlF3scKIcSEKkdHzXhCTDLPFi5r1wnK6yPS+49Gw= github.com/pelletier/go-toml/v2 v2.0.2/go.mod h1:MovirKjgVRESsAvNZlAjtFwV867yGuwRkXbG66OzopI= +github.com/performancecopilot/speed v3.0.0+incompatible/go.mod h1:/CLtqpZ5gBg1M9iaPbIdPPGyKcA8hKdoy6hAWba7Yac= github.com/performancecopilot/speed/v4 v4.0.0/go.mod h1:qxrSyuDGrTOWfV+uKRFhfxw6h/4HXRGUiZiufxo49BM= github.com/peterbourgon/diskv v2.0.1+incompatible/go.mod h1:uqqh8zWWbv1HBMNONnaR/tNboyR3/BZd58JJSHlUSCU= github.com/petermattis/goid v0.0.0-20180202154549-b0b1615b78e5 h1:q2e307iGHPdTGp0hoxKjt1H5pDo6utceo3dQVK3I5XQ= @@ -855,51 +959,69 @@ github.com/petermattis/goid v0.0.0-20180202154549-b0b1615b78e5/go.mod h1:jvVRKCr github.com/phayes/checkstyle v0.0.0-20170904204023-bfd46e6a821d/go.mod h1:3OzsM7FXDQlpCiw2j81fOmAwQLnZnLGXVKUzeKQXIAw= github.com/philhofer/fwd v1.1.1/go.mod h1:gk3iGcWd9+svBvR0sR+KPcfE+RNWozjowpeBVG3ZVNU= github.com/pierrec/lz4 v1.0.2-0.20190131084431-473cd7ce01a1/go.mod h1:3/3N9NVKO0jef7pBehbT1qWhCMrIgbYNnFAZCqQ5LRc= +github.com/pierrec/lz4 v2.0.5+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY= github.com/pkg/browser v0.0.0-20180916011732-0a3d74bf9ce4/go.mod h1:4OwLy04Bl9Ef3GJJCoec+30X3LQs/0/m4HFRt/2LUSA= +github.com/pkg/browser v0.0.0-20210911075715-681adbf594b8/go.mod h1:HKlIX3XHQyzLZPlr7++PzdhaXEj94dEiJgZDTsxEqUI= github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/profile v1.2.1/go.mod h1:hJw3o1OdXxsrSjjVksARp5W95eeEaEfptyVZyv6JUPA= +github.com/pkg/profile v1.6.0/go.mod h1:qBsxPvzyUincmltOk6iyRVxHYg4adc0OFOv72ZdLa18= github.com/pkg/sftp v1.10.1/go.mod h1:lYOWFsE0bwd1+KfKJaKeuokY15vzFx25BLbzYYoAxZI= github.com/pkg/sftp v1.13.1/go.mod h1:3HaPG6Dq1ILlpPZRO0HVMrsydcdLt6HRDccSgb87qRg= github.com/pmezard/go-difflib v0.0.0-20151028094244-d8ed2627bdf0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/polyfloyd/go-errorlint v0.0.0-20211125173453-6d6d39c5bb8b/go.mod h1:wi9BfjxjF/bwiZ701TzmfKu6UKC357IOAtNr0Td0Lvw= +github.com/polyfloyd/go-errorlint v1.0.0/go.mod h1:KZy4xxPJyy88/gldCe5OdW6OQRtNO3EZE7hXzmnebgA= github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI= github.com/posener/complete v1.2.3/go.mod h1:WZIdtGGp+qx0sLrYKtIRAruyNpv6hFCicSgv7Sy7s/s= github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE= github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw= +github.com/prometheus/client_golang v0.9.3-0.20190127221311-3c4408c8b829/go.mod h1:p2iRAGwDERtqlqzRXnrOVns+ignqQo//hLXqYxZYVNs= +github.com/prometheus/client_golang v0.9.3/go.mod h1:/TN21ttK/J9q6uSwhBd54HahCDft0ttaMvbicHlPoso= github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo= +github.com/prometheus/client_golang v1.3.0/go.mod h1:hJaj2vgQTGQmVCsAACORcieXFeDPbaTKGT+JTgUa3og= github.com/prometheus/client_golang v1.4.0/go.mod h1:e9GMxYsXl05ICDXkRhurwBS4Q3OK1iX/F2sw+iXX5zU= github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M= +github.com/prometheus/client_golang v1.8.0/go.mod h1:O9VU6huf47PktckDQfMTX0Y8tY0/7TSWwj+ITvv0TnM= github.com/prometheus/client_golang v1.11.0/go.mod h1:Z6t4BnS23TR94PD6BsDNk8yVqroYurpAkEiz0P2BEV0= github.com/prometheus/client_golang v1.11.1/go.mod h1:Z6t4BnS23TR94PD6BsDNk8yVqroYurpAkEiz0P2BEV0= github.com/prometheus/client_golang v1.12.1/go.mod h1:3Z9XVyYiZYEO+YQWt3RD2R3jrbd179Rt297l4aS6nDY= github.com/prometheus/client_golang v1.12.2 h1:51L9cDoUHVrXx4zWYlcLQIZ+d+VXHgqnYKkIuq4g/34= github.com/prometheus/client_golang v1.12.2/go.mod h1:3Z9XVyYiZYEO+YQWt3RD2R3jrbd179Rt297l4aS6nDY= github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo= +github.com/prometheus/client_model v0.0.0-20190115171406-56726106282f/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo= github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= +github.com/prometheus/client_model v0.1.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= github.com/prometheus/client_model v0.2.0 h1:uq5h0d+GuxiXLJLNABMgp2qUWDPiLvgCzz2dUR+/W/M= github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= +github.com/prometheus/common v0.0.0-20181113130724-41aa239b4cce/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro= +github.com/prometheus/common v0.2.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4= +github.com/prometheus/common v0.4.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4= github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4= +github.com/prometheus/common v0.7.0/go.mod h1:DjGbpBbp5NYNiECxcL/VnbXCCaQpKd3tt26CguLLsqA= github.com/prometheus/common v0.9.1/go.mod h1:yhUN8i9wzaXS3w1O07YhxHEBxD+W35wd8bs7vj7HSQ4= github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo= +github.com/prometheus/common v0.14.0/go.mod h1:U+gB1OBLb1lF3O42bTCL+FK18tX9Oar16Clt/msog/s= github.com/prometheus/common v0.26.0/go.mod h1:M7rCNAaPfAosfx8veZJCuw84e35h3Cfd9VFqTh1DIvc= github.com/prometheus/common v0.30.0/go.mod h1:vu+V0TpY+O6vW9J44gczi3Ap/oXXR10b+M/gUGO4Hls= github.com/prometheus/common v0.32.1/go.mod h1:vu+V0TpY+O6vW9J44gczi3Ap/oXXR10b+M/gUGO4Hls= github.com/prometheus/common v0.34.0 h1:RBmGO9d/FVjqHT0yUGQwBJhkwKV+wPCn7KGpvfab0uE= github.com/prometheus/common v0.34.0/go.mod h1:gB3sOl7P0TvJabZpLY5uQMpUqRCPPCyRLCZYc7JZTNE= github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk= +github.com/prometheus/procfs v0.0.0-20190117184657-bf6a532e95b1/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk= +github.com/prometheus/procfs v0.0.0-20190507164030-5867b95ac084/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA= github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA= github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A= github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU= +github.com/prometheus/procfs v0.2.0/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU= github.com/prometheus/procfs v0.6.0/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA= github.com/prometheus/procfs v0.7.3 h1:4jVXhlkAyzOScmCkXBTOLRLTz8EeU+eyjrwB/EPq0VU= github.com/prometheus/procfs v0.7.3/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA= +github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU= github.com/pseudomuto/protoc-gen-doc v1.3.2/go.mod h1:y5+P6n3iGrbKG+9O04V5ld71in3v/bX88wUwgt+U8EA= github.com/pseudomuto/protokit v0.2.0/go.mod h1:2PdH30hxVHsup8KpBTOXTBeMVhJZVio3Q8ViKSAXT0Q= github.com/quasilyte/go-ruleguard v0.3.1-0.20210203134552-1b5a410e1cc8/go.mod h1:KsAh3x0e7Fkpgs+Q9pNLS5XpFSvYCEVl5gP9Pp1xp30= @@ -943,10 +1065,12 @@ github.com/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb github.com/sagikazarmark/crypt v0.3.0/go.mod h1:uD/D+6UF4SrIR1uGEv7bBNkNqLGqUr43MRiaGWX1Nig= github.com/sagikazarmark/crypt v0.5.0/go.mod h1:l+nzl7KWh51rpzp2h7t4MZWyiEWdhNpOAnclKvg+mdA= github.com/sagikazarmark/crypt v0.6.0/go.mod h1:U8+INwJo3nBv1m6A/8OBXAq7Jnpspk5AxSgDyEQcea8= +github.com/samuel/go-zookeeper v0.0.0-20190923202752-2cc03de413da/go.mod h1:gi+0XIa01GRL2eRQVjQkKGqKF3SF9vZR/HnPullcV2E= github.com/sanposhiho/wastedassign/v2 v2.0.6/go.mod h1:KyZ0MWTwxxBmfwn33zh3k1dmsbF2ud9pAAGfoLfjhtI= github.com/sasha-s/go-deadlock v0.2.1-0.20190427202633-1595213edefa h1:0U2s5loxrTy6/VgfVoLuVLFJcURKLH49ie0zSch7gh4= github.com/sasha-s/go-deadlock v0.2.1-0.20190427202633-1595213edefa/go.mod h1:F73l+cr82YSh10GxyRI6qZiCgK64VaZjwesgfQ1/iLM= github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc= +github.com/seccomp/libseccomp-golang v0.9.1/go.mod h1:GbW5+tmTXfcxTToHLXlScSlAvWlF4P2Ca7zGrPiEpWo= github.com/seccomp/libseccomp-golang v0.9.2-0.20210429002308-3879420cc921/go.mod h1:JA8cRccbGaA1s33RQf7Y1+q9gHmZX1yB/z9WDN1C6fg= github.com/seccomp/libseccomp-golang v0.9.2-0.20220502022130-f33da4d89646/go.mod h1:JA8cRccbGaA1s33RQf7Y1+q9gHmZX1yB/z9WDN1C6fg= github.com/securego/gosec/v2 v2.11.0/go.mod h1:SX8bptShuG8reGC0XS09+a4H2BoWSJi+fscA+Pulbpo= @@ -957,6 +1081,7 @@ github.com/shurcooL/go v0.0.0-20180423040247-9e1955d9fb6e/go.mod h1:TDJrrUr11Vxr github.com/shurcooL/go-goon v0.0.0-20170922171312-37c2f522c041/go.mod h1:N5mDOmsrJOB+vfqUK+7DmDyjhSLIIBnXo9lvZJj3MWQ= github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc= github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo= +github.com/sirupsen/logrus v1.4.1/go.mod h1:ni0Sbl8bgC9z8RoU9G6nDWqqs/fq4eDPysMBDgk/93Q= github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE= github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88= github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0= @@ -984,6 +1109,7 @@ github.com/spf13/cast v1.5.0 h1:rj3WzYc11XZaIZMPKmwP96zkFEnnAmV8s6XbB2aY32w= github.com/spf13/cast v1.5.0/go.mod h1:SpXXQ5YoyJw6s3/6cMTQuxvgRl3PCJiyaX9p6b155UU= github.com/spf13/cobra v0.0.3/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ= github.com/spf13/cobra v0.0.5/go.mod h1:3K3wKZymM7VvHMDS9+Akkh4K60UwM26emMESw8tLCHU= +github.com/spf13/cobra v1.1.1/go.mod h1:WnodtKOvamDL/PwE2M4iKs8aMDBZ5Q5klgD3qfVJQMI= github.com/spf13/cobra v1.3.0/go.mod h1:BrRVncBjOJa/eUcVVm9CE+oC6as8k+VYr4NY7WCi9V4= github.com/spf13/cobra v1.4.0/go.mod h1:Wo4iy3BUC+X2Fybo0PDqwJIv3dNRiZLHQymsfxlB84g= github.com/spf13/cobra v1.5.0 h1:X+jTBEBqF0bHN+9cSMgmfuvv2VHJ9ezmFNf9Y/XstYU= @@ -996,6 +1122,8 @@ github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnIn github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA= github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= github.com/spf13/viper v1.3.2/go.mod h1:ZiWeW+zYFKm7srdB9IoDzzZXaJaI5eL9QjNiN/DMA2s= +github.com/spf13/viper v1.7.0/go.mod h1:8WkrPz2fc9jxqZNCJI/76HCieCp4Q8HaLFoCha5qpdg= +github.com/spf13/viper v1.7.1/go.mod h1:8WkrPz2fc9jxqZNCJI/76HCieCp4Q8HaLFoCha5qpdg= github.com/spf13/viper v1.10.0/go.mod h1:SoyBPwAtKDzypXNDFKN5kzH7ppppbGZtls1UpIy5AsM= github.com/spf13/viper v1.11.0/go.mod h1:djo0X/bA5+tYVoCn+C7cAYJGcVn/qYLFTG8gdUsX7Zk= github.com/spf13/viper v1.12.0 h1:CZ7eSOd3kZoaYDLbXnmzgQI5RlciuXBMA+18HwHRfZQ= @@ -1003,7 +1131,9 @@ github.com/spf13/viper v1.12.0/go.mod h1:b6COn30jlNxbm/V2IqWiNWkJ+vZNiMNksliPCiu github.com/ssgreg/nlreturn/v2 v2.2.1/go.mod h1:E/iiPB78hV7Szg2YfRgyIrk1AD6JVMTRkkxBiELzh2I= github.com/stbenjam/no-sprintf-host-port v0.1.1/go.mod h1:TLhvtIvONRzdmkFiio4O8LHsN9N74I+PhRquPsxpL0I= github.com/streadway/amqp v0.0.0-20190404075320-75d898a42a94/go.mod h1:AZpEONHx3DKn8O/DFsRAY58/XVQiIPMTMB1SddzLXVw= +github.com/streadway/amqp v0.0.0-20190827072141-edfb9018d271/go.mod h1:AZpEONHx3DKn8O/DFsRAY58/XVQiIPMTMB1SddzLXVw= github.com/streadway/amqp v1.0.0/go.mod h1:AZpEONHx3DKn8O/DFsRAY58/XVQiIPMTMB1SddzLXVw= +github.com/streadway/handy v0.0.0-20190108123426-d5acb3125c2a/go.mod h1:qNTQ5P5JnDBl6z3cMAg/SywNDC5ABu5ApDIw6lUbRmI= github.com/streadway/handy v0.0.0-20200128134331-0f66f006fb2e/go.mod h1:qNTQ5P5JnDBl6z3cMAg/SywNDC5ABu5ApDIw6lUbRmI= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= @@ -1020,6 +1150,7 @@ github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/ github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.7.2/go.mod h1:R6va5+xMeoiuVRoj+gSkQ7d3FALtqAAGI1FQKckRals= +github.com/stretchr/testify v1.7.5/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk= github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/subosito/gotenv v1.2.0/go.mod h1:N0PQaV/YGNqwC0u51sEeR/aUtSLEXKX9iv69rRypqCw= @@ -1040,8 +1171,10 @@ github.com/tendermint/crypto v0.0.0-20191022145703-50d29ede1e15 h1:hqAk8riJvK4RM github.com/tendermint/crypto v0.0.0-20191022145703-50d29ede1e15/go.mod h1:z4YtwM70uOnk8h0pjJYlj3zdYwi9l03By6iAIF5j/Pk= github.com/tendermint/go-amino v0.16.0 h1:GyhmgQKvqF82e2oZeuMSp9JTN0N09emoSZlb2lyGa2E= github.com/tendermint/go-amino v0.16.0/go.mod h1:TQU0M1i/ImAo+tYpZi73AU3V/dKeCoMC9Sphe2ZwGME= -github.com/tendermint/tendermint v0.35.7 h1:qDgVwmKwR/YEfx/kas/D/qQbZBSlCEe7ze1KHTz4/Ys= -github.com/tendermint/tendermint v0.35.7/go.mod h1:sMxFpYJSZxltyv/7m5RxtTOXvd8uunr1c2QCs+/dV2A= +github.com/tendermint/tendermint v0.34.14/go.mod h1:FrwVm3TvsVicI9Z7FlucHV6Znfd5KBc/Lpp69cCwtk0= +github.com/tendermint/tendermint v0.34.20-rc0 h1:k0AtVmig69jDMyprn4zIMQJzgonyqZM2sFGN7TlKrIk= +github.com/tendermint/tendermint v0.34.20-rc0/go.mod h1:JZIr6ZIN2MDjKJvM+PLhMfAgEAWNuyxVQRaDOkaFv+E= +github.com/tendermint/tm-db v0.6.4/go.mod h1:dptYhIpJ2M5kUuenLr+Yyf3zQOv1SgBZcl8/BmWlMBw= github.com/tendermint/tm-db v0.6.6 h1:EzhaOfR0bdKyATqcd5PNeyeq8r+V4bRPHBfyFdD9kGM= github.com/tendermint/tm-db v0.6.6/go.mod h1:wP8d49A85B7/erz/r4YbKssKw6ylsO/hKtFk7E1aWZI= github.com/tenntenn/modver v1.0.1/go.mod h1:bePIyQPb7UeioSRkw3Q0XeMhYZSMx9B8ePqg6SAMGH0= @@ -1099,10 +1232,13 @@ github.com/zondax/hid v0.9.0/go.mod h1:l5wttcP0jwtdLjqjMMWFVEE7d1zO0jvSPA9OPZxWp github.com/zondax/hid v0.9.1-0.20220302062450-5552068d2266 h1:O9XLFXGkVswDFmH9LaYpqu+r/AAFWqr0DL6V00KEVFg= github.com/zondax/hid v0.9.1-0.20220302062450-5552068d2266/go.mod h1:l5wttcP0jwtdLjqjMMWFVEE7d1zO0jvSPA9OPZxWpEM= gitlab.com/bosi/decorder v0.2.1/go.mod h1:6C/nhLSbF6qZbYD8bRmISBwc6vcWdNsiIBkRvjJFrH0= +go.etcd.io/bbolt v1.3.2/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU= go.etcd.io/bbolt v1.3.3/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU= go.etcd.io/bbolt v1.3.4/go.mod h1:G5EMThwa9y8QZGBClrRx5EY+Yw9kAhnjy3bSjsnlVTQ= +go.etcd.io/bbolt v1.3.5/go.mod h1:G5EMThwa9y8QZGBClrRx5EY+Yw9kAhnjy3bSjsnlVTQ= go.etcd.io/bbolt v1.3.6 h1:/ecaJf0sk1l4l6V4awd65v2C3ILy7MSj+s/x1ADCIMU= go.etcd.io/bbolt v1.3.6/go.mod h1:qXsaaIqmgQH0T+OPdb99Bf+PKfBBQVAdyD6TY9G8XM4= +go.etcd.io/etcd v0.0.0-20191023171146-3cf2f69b5738/go.mod h1:dnLIgRNXwCJa5e+c6mIZCrds/GIG4ncV9HhK5PX7jPg= go.etcd.io/etcd v0.0.0-20200513171258-e048e166ab9c/go.mod h1:xCI7ZzBfRuGgBXyXO6yfWfDmlWd35khcWpUa4L0xI/k= go.etcd.io/etcd/api/v3 v3.5.0/go.mod h1:cbVKeC6lCfl7j/8jBhAK6aIYO9XOjdptoxU/nLQcPvs= go.etcd.io/etcd/api/v3 v3.5.1/go.mod h1:cbVKeC6lCfl7j/8jBhAK6aIYO9XOjdptoxU/nLQcPvs= @@ -1119,6 +1255,8 @@ go.etcd.io/etcd/client/v2 v2.305.4/go.mod h1:Ud+VUwIi9/uQHOMA+4ekToJ12lTxlv0zB/+ go.etcd.io/etcd/client/v3 v3.5.0/go.mod h1:AIKXXVX/DQXtfTEqBryiLTUXwON+GuvO6Z7lLS/oTh0= go.etcd.io/etcd/client/v3 v3.5.4/go.mod h1:ZaRkVgBZC+L+dLCjTcF1hRXpgZXQPOvnA/Ak/gq3kiY= go.mozilla.org/mozlog v0.0.0-20170222151521-4bb13139d403/go.mod h1:jHoPAGnDrCy6kaI2tAze5Prf0Nr0w/oNkROt2lw3n3o= +go.opencensus.io v0.20.1/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk= +go.opencensus.io v0.20.2/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk= go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU= go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8= go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= @@ -1134,16 +1272,19 @@ go.uber.org/atomic v1.5.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ= go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= go.uber.org/goleak v1.1.11-0.20210813005559-691160354723/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ= +go.uber.org/goleak v1.1.11/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ= go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0= go.uber.org/multierr v1.3.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4= go.uber.org/multierr v1.4.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4= go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU= go.uber.org/multierr v1.7.0/go.mod h1:7EAYxJLBy9rStEaz58O2t4Uvip6FSURkq8/ppBp95ak= +go.uber.org/multierr v1.8.0/go.mod h1:7EAYxJLBy9rStEaz58O2t4Uvip6FSURkq8/ppBp95ak= go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9Ejo0C68/HhF8uaILCdgjnY+goOA= go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q= go.uber.org/zap v1.13.0/go.mod h1:zwrFLgMcdUuIBviXEYEH1YKNaOBnKXsx2IPda5bBwHM= go.uber.org/zap v1.17.0/go.mod h1:MXVU+bhUf/A7Xi2HNOnopQOrmycQ5Ih87HtOu4q5SSo= go.uber.org/zap v1.19.1/go.mod h1:j3DNczoxDZroyBnOT1L/Q79cfUMGZxlv/9dzN7SM1rI= +go.uber.org/zap v1.21.0/go.mod h1:wjWOCqI0f2ZZrJF/UufIOkiC8ii6tm1iqIsLo76RfJw= golang.org/x/crypto v0.0.0-20170930174604-9419663f5a44/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20180501155221-613d6eafa307/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= @@ -1156,12 +1297,14 @@ golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8U golang.org/x/crypto v0.0.0-20190820162420-60c769a6c586/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190923035154-9ee001bba392/go.mod h1:/lpIB1dKB+9EgE3H3cr1v9wB50oz8l4C4h62xy7jSTY= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20191206172530-e9b2fee46413/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20200115085410-6d4e4cb37c7d/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20200323165209-0ec3e9974c59/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20200510223506-06a226fb4e37/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20200728195943-123391ffb6de/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.0.0-20201117144127-c1f2f97bffc9/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I= golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I= golang.org/x/crypto v0.0.0-20210314154223-e6e6c4f2bb5b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4= golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4= @@ -1226,8 +1369,10 @@ golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73r golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20181023162649-9b4f9f5ad519/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20181201002055-351d144fa1fc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190125091013-d26f9f9a57f3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= @@ -1276,6 +1421,7 @@ golang.org/x/net v0.0.0-20210610132358-84b48f89b13b/go.mod h1:9nx3DQGgdP8bBQD5qx golang.org/x/net v0.0.0-20210614182718-04defd469f4e/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20210805182204-aaa1db679c0d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20210813160813-60bc85c4be6d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20210903162142-ad29c8ab022f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20210917221730-978cfadd31cf/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= @@ -1320,7 +1466,6 @@ golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJ golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20220513210516-0976fa681c29 h1:w8s32wxx3sY+OjLlv9qltkLU5yvJzxjjgiHWLjdIcw4= golang.org/x/sync v0.0.0-20220513210516-0976fa681c29/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= @@ -1329,6 +1474,7 @@ golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5h golang.org/x/sys v0.0.0-20181026203630-95b1ffbd15a5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20181122145206-62eef0e2fa9b/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20181205085412-a5c9d58dba9a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190130150945-aca44879d564/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= @@ -1356,6 +1502,7 @@ golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20191115151921-52ab43148777/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191220142924-d4481acd189f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -1380,8 +1527,10 @@ golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20200814200057-3d37ad5750ed/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200831180312-196b9ba8737a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200905004654-be1d3432aa8f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200909081042-eff7692f9009/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200923182605-d9f96fdee20d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201015000850-e3ed0017c211/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201201145000-ef89a241ccb3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201204225414-ed752295db88/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -1399,17 +1548,20 @@ golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210423185535-09eb48e85fd7/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210426230700-d19ff857e887/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210514084401-e8d321eab015/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210603125802-9665404d3644/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210616045830-e2b7044e8c71/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210806184541-e5e7981a1069/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210816183151-1e6c022a8912/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210823070655-63515b42dcdf/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210903071746-97244b99971b/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210906170528-6f6e22806c34/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210908233432-aa78b53d3365/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210917161153-d61c044b1678/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= @@ -1444,6 +1596,7 @@ golang.org/x/sys v0.0.0-20220615213510-4f61da869c0c/go.mod h1:oPkhp1MJrh7nUepCBc golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= +golang.org/x/term v0.0.0-20220411215600-e5f449aeb171/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= golang.org/x/term v0.0.0-20220526004731-065cf7ba2467 h1:CBpWXWQpIRjzmkkA+M7q9Fqnwd2mZr3AFqexg8YTfoM= golang.org/x/term v0.0.0-20220526004731-065cf7ba2467/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= @@ -1463,6 +1616,7 @@ golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxb golang.org/x/time v0.0.0-20200416051211-89c76fbcd5d1/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20210723032227-1f47c861a9ac/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/tools v0.0.0-20180525024113-a5b4c53f6e8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190206041539-40960b6deb8e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= @@ -1493,6 +1647,7 @@ golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtn golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191108193012-7d206e10da11/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191112195655-aa38f8e97acc/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= @@ -1501,6 +1656,7 @@ golang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtn golang.org/x/tools v0.0.0-20191216052735-49a3e744a425/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200103221440-774c71fcf114/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20200117161641-43d50277825c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20200117220505-0cba7a3a9ee9/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20200122220014-bf1340f18c4a/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= @@ -1576,6 +1732,7 @@ gonum.org/v1/gonum v0.0.0-20180816165407-929014505bf4/go.mod h1:Y+Yx5eoAFn32cQvJ gonum.org/v1/gonum v0.8.2/go.mod h1:oe/vMfY3deqTw+1EZJhuvEW2iwGF1bW9wwu7XCu0+v0= gonum.org/v1/netlib v0.0.0-20190313105609-8cb42192e0e0/go.mod h1:wa6Ws7BG/ESfp6dHfk7C6KdzKA7wR7u/rKwOGE66zvw= gonum.org/v1/plot v0.0.0-20190515093506-e2840ee46a6b/go.mod h1:Wt8AAjI+ypCyYX3nZBvf6cAIx93T+c/OS2HFAYskSZc= +google.golang.org/api v0.3.1/go.mod h1:6wY9I6uQWHQ8EM57III9mq/AjF+i8G65rmVagqKMtkk= google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE= google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M= google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg= @@ -1619,6 +1776,7 @@ google.golang.org/api v0.78.0/go.mod h1:1Sg78yoMLOhlQTeF+ARBoytAcH1NNyyl390YMy6r google.golang.org/api v0.81.0 h1:o8WF5AvfidafWbFjsRyupxyEQJNUWxLZJCK5NXrxZZ8= google.golang.org/api v0.81.0/go.mod h1:FA6Mb/bZxj706H2j+j2d6mHEEaHBmbbWnkfvmorOCko= google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= +google.golang.org/appengine v1.2.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0= @@ -1635,6 +1793,7 @@ google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRn google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190530194941-fb225487d101/go.mod h1:z3L6/3dTEVtUr6QSP8miRzeRqwQOioJ9I66odjN4I7s= google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8= @@ -1667,6 +1826,7 @@ google.golang.org/genproto v0.0.0-20200804131852-c06518451d9c/go.mod h1:FWY/as6D google.golang.org/genproto v0.0.0-20200825200019-8632dd797987/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20200904004341-0bd0a958aa1d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20201109203340-2640f1f9cdfb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20201119123407-9b1e624d6bc4/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20201201144952-b05cb90ed32e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20201210142538-e3217bee35cc/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20201214200347-8c77b98c765d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= @@ -1718,9 +1878,14 @@ google.golang.org/genproto v0.0.0-20220505152158-f39f71e6c8f3/go.mod h1:RAyBrSAP google.golang.org/genproto v0.0.0-20220519153652-3a47de7e79bd h1:e0TwkXOdbnH/1x5rc5MZ/VYyiZ4v+RdVfrGMqEwT68I= google.golang.org/genproto v0.0.0-20220519153652-3a47de7e79bd/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4= google.golang.org/grpc v1.8.0/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw= +google.golang.org/grpc v1.17.0/go.mod h1:6QZJwpn2B+Zp71q/5VxRsJ6NXXVCE5NRUHRo+f3cWCs= google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= +google.golang.org/grpc v1.19.1/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= +google.golang.org/grpc v1.20.0/go.mod h1:chYK+tFQF0nDUGJgXMSgLCQk3phJEuONr2DCgLDdAQM= google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38= +google.golang.org/grpc v1.21.0/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM= google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM= +google.golang.org/grpc v1.22.1/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= google.golang.org/grpc v1.23.1/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= google.golang.org/grpc v1.24.0/go.mod h1:XDChyiUovWa60DnaeDeZmSW86xtLtjtZbwvSiRnRtcA= @@ -1767,6 +1932,7 @@ google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGj google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c= google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= +google.golang.org/protobuf v1.27.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= google.golang.org/protobuf v1.28.0 h1:w43yiav+6bVFTBQFZX0r7ipe9JQ1QsbMgHwbBziscLw= google.golang.org/protobuf v1.28.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= @@ -1783,6 +1949,7 @@ gopkg.in/cheggaaa/pb.v1 v1.0.28/go.mod h1:V/YB90LKu/1FcN3WVnfiiE5oMCibMjukxqG/qS gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI= gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys= gopkg.in/gcfg.v1 v1.2.3/go.mod h1:yesOnuUOFQAhST5vPY4nbZsb/huCgGGXlipJsBn0b3o= +gopkg.in/ini.v1 v1.51.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= gopkg.in/ini.v1 v1.66.2/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= gopkg.in/ini.v1 v1.66.4/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= gopkg.in/ini.v1 v1.66.6 h1:LATuAqN/shcYAOkv3wl2L4rkaKqkcgTBQjOyYDvcPKI= @@ -1810,6 +1977,7 @@ gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gotest.tools v2.2.0+incompatible/go.mod h1:DsYFclhRJ6vuDpmuTbkuFWG+y2sxOXAzmJt81HFBacw= gotest.tools/v3 v3.0.2/go.mod h1:3SzNCllyD9/Y+b5r9JIKQ474KzkZyqLqEfYqMsX94Bk= gotest.tools/v3 v3.2.0/go.mod h1:Mcr9QNxkg0uMvy/YElmo4SpXgJKWgQvYrT7Kw5RzJ1A= +honnef.co/go/tools v0.0.0-20180728063816-88497007e858/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= @@ -1832,3 +2000,4 @@ sigs.k8s.io/yaml v1.1.0/go.mod h1:UJmg0vDUVViEyp3mgSv9WPwZCDxu4rQW1olrI1uml+o= sigs.k8s.io/yaml v1.2.0/go.mod h1:yfXDCHCao9+ENCvLSE62v9VSji2MKu5jeNfTrofGhJc= sigs.k8s.io/yaml v1.3.0 h1:a2VclLzOGrwOHDiV8EfBGhvjHvP46CtW5j6POvhYGGo= sigs.k8s.io/yaml v1.3.0/go.mod h1:GeOyir5tyXNByN85N/dRIT9es5UQNerPYEKK56eTBm8= +sourcegraph.com/sourcegraph/appdash v0.0.0-20190731080439-ebfcffb1b5c0/go.mod h1:hI742Nqp5OhwiqlzhgfbWU4mW4yO10fP+LoT9WOswdU= diff --git a/go.mod b/go.mod index a8030774b1e8..01f6472bb5a0 100644 --- a/go.mod +++ b/go.mod @@ -5,6 +5,7 @@ module github.com/cosmos/cosmos-sdk require ( cosmossdk.io/api v0.1.0-alpha8 cosmossdk.io/core v0.0.0 + cosmossdk.io/depinject v1.0.0-alpha.4 cosmossdk.io/errors v1.0.0-beta.7 cosmossdk.io/math v1.0.0-beta.2 github.com/99designs/keyring v1.1.6 @@ -17,7 +18,6 @@ require ( github.com/cosmos/btcutil v1.0.4 github.com/cosmos/cosmos-proto v1.0.0-alpha7 github.com/cosmos/cosmos-sdk/db v1.0.0-beta.1 - cosmossdk.io/depinject v1.0.0-alpha.4 github.com/cosmos/cosmos-sdk/store/tools/ics23 v0.0.0-20220608170201-b0e82f964070 github.com/cosmos/go-bip39 v1.0.0 github.com/cosmos/iavl v0.18.0 @@ -56,7 +56,7 @@ require ( github.com/tendermint/crypto v0.0.0-20191022145703-50d29ede1e15 github.com/tendermint/go-amino v0.16.0 github.com/tendermint/tendermint v0.35.6 - github.com/tendermint/tm-db v0.6.6 + github.com/tendermint/tm-db v0.6.7 golang.org/x/crypto v0.0.0-20220411220226-7b82a4e95df4 golang.org/x/exp v0.0.0-20220428152302-39d4317da171 google.golang.org/genproto v0.0.0-20220519153652-3a47de7e79bd @@ -98,6 +98,7 @@ require ( github.com/cespare/xxhash/v2 v2.1.2 // indirect github.com/charithe/durationcheck v0.0.9 // indirect github.com/chavacava/garif v0.0.0-20220316182200-5cad0b5181d4 // indirect + github.com/cosmos/gorocksdb v1.2.0 // indirect github.com/cosmos/ledger-go v0.9.2 // indirect github.com/creachadair/taskgroup v0.3.2 // indirect github.com/daixiang0/gci v0.3.3 // indirect @@ -111,8 +112,6 @@ require ( github.com/dvsekhvalnov/jose2go v0.0.0-20200901110807-248326c1351b // indirect github.com/esimonov/ifshort v1.0.4 // indirect github.com/ettle/strcase v0.1.1 // indirect - github.com/facebookgo/ensure v0.0.0-20200202191622-63f1cf65ac4c // indirect - github.com/facebookgo/subset v0.0.0-20200203212716-c811ad88dec4 // indirect github.com/fatih/color v1.13.0 // indirect github.com/fatih/structtag v1.2.0 // indirect github.com/felixge/httpsnoop v1.0.1 // indirect @@ -237,7 +236,6 @@ require ( github.com/sylvia7788/contextcheck v1.0.4 // indirect github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 // indirect github.com/tdakkota/asciicheck v0.1.1 // indirect - github.com/tecbot/gorocksdb v0.0.0-20191217155057-f0fad39f321c // indirect github.com/tetafro/godot v1.4.11 // indirect github.com/timakin/bodyclose v0.0.0-20210704033933-f49887972144 // indirect github.com/tomarrell/wrapcheck/v2 v2.6.1 // indirect @@ -278,9 +276,9 @@ require ( replace ( cosmossdk.io/api => ./api cosmossdk.io/core => ./core + cosmossdk.io/depinject => ./depinject github.com/99designs/keyring => github.com/cosmos/keyring v1.1.7-0.20210622111912-ef00f8ac3d76 github.com/cosmos/cosmos-sdk/db => ./db - cosmossdk.io/depinject => ./depinject // Fix upstream GHSA-h395-qcrw-5vmq vulnerability. // TODO Remove it: https://github.com/cosmos/cosmos-sdk/issues/10409 diff --git a/go.sum b/go.sum index fe4b3e1fbafd..ee55e89b6965 100644 --- a/go.sum +++ b/go.sum @@ -274,6 +274,8 @@ github.com/cosmos/cosmos-sdk/store/tools/ics23 v0.0.0-20220608170201-b0e82f96407 github.com/cosmos/cosmos-sdk/store/tools/ics23 v0.0.0-20220608170201-b0e82f964070/go.mod h1:EOXK+a/6yV5rT46k8UaI56UwE+AU1uq712wy6IbG5+E= github.com/cosmos/go-bip39 v1.0.0 h1:pcomnQdrdH22njcAatO0yWojsUnCO3y2tNoV1cb6hHY= github.com/cosmos/go-bip39 v1.0.0/go.mod h1:RNJv0H/pOIVgxw6KS7QeX2a0Uo0aKUlfhZ4xuwvCdJw= +github.com/cosmos/gorocksdb v1.2.0 h1:d0l3jJG8M4hBouIZq0mDUHZ+zjOx044J3nGRskwTb4Y= +github.com/cosmos/gorocksdb v1.2.0/go.mod h1:aaKvKItm514hKfNJpUJXnnOWeBnk2GL4+Qw9NHizILw= github.com/cosmos/iavl v0.18.0 h1:02ur4vnalMR2GuWCFNkuseUcl/BCVmg9tOeHOGiZOkE= github.com/cosmos/iavl v0.18.0/go.mod h1:L0VZHfq0tqMNJvXlslGExaaiZM7eSm+90Vh9QUbp6j4= github.com/cosmos/keyring v1.1.7-0.20210622111912-ef00f8ac3d76 h1:DdzS1m6o/pCqeZ8VOAit/gyATedRgjvkVI+UCrLpyuU= @@ -357,12 +359,10 @@ github.com/ettle/strcase v0.1.1 h1:htFueZyVeE1XNnMEfbqp5r67qAN/4r6ya1ysq8Q+Zcw= github.com/ettle/strcase v0.1.1/go.mod h1:hzDLsPC7/lwKyBOywSHEP89nt2pDgdy+No1NBA9o9VY= github.com/facebookgo/ensure v0.0.0-20160127193407-b4ab57deab51/go.mod h1:Yg+htXGokKKdzcwhuNDwVvN+uBxDGXJ7G/VN1d8fa64= github.com/facebookgo/ensure v0.0.0-20200202191622-63f1cf65ac4c h1:8ISkoahWXwZR41ois5lSJBSVw4D0OV19Ht/JSTzvSv0= -github.com/facebookgo/ensure v0.0.0-20200202191622-63f1cf65ac4c/go.mod h1:Yg+htXGokKKdzcwhuNDwVvN+uBxDGXJ7G/VN1d8fa64= github.com/facebookgo/stack v0.0.0-20160209184415-751773369052 h1:JWuenKqqX8nojtoVVWjGfOF9635RETekkoH6Cc9SX0A= github.com/facebookgo/stack v0.0.0-20160209184415-751773369052/go.mod h1:UbMTZqLaRiH3MsBH8va0n7s1pQYcu3uTb8G4tygF4Zg= github.com/facebookgo/subset v0.0.0-20150612182917-8dac2c3c4870/go.mod h1:5tD+neXqOorC30/tWg0LCSkrqj/AR6gu8yY8/fpw1q0= github.com/facebookgo/subset v0.0.0-20200203212716-c811ad88dec4 h1:7HZCaLC5+BZpmbhCOZJ293Lz68O7PYrF2EzeiFMwCLk= -github.com/facebookgo/subset v0.0.0-20200203212716-c811ad88dec4/go.mod h1:5tD+neXqOorC30/tWg0LCSkrqj/AR6gu8yY8/fpw1q0= github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4= github.com/fatih/color v1.9.0/go.mod h1:eQcE1qtQxscV5RaZvpXrrb8Drkc3/DdQ+uUYCNjL+zU= github.com/fatih/color v1.10.0/go.mod h1:ELkj/draVOlAH/xkhN6mQ50Qd0MPOk5AAr3maGEBuJM= @@ -1262,7 +1262,6 @@ github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 h1:epCh84lMvA70 github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc= github.com/tdakkota/asciicheck v0.1.1 h1:PKzG7JUTUmVspQTDqtkX9eSiLGossXTybutHwTXuO0A= github.com/tdakkota/asciicheck v0.1.1/go.mod h1:yHp0ai0Z9gUljN3o0xMhYJnH/IcvkdTBOX2fmJ93JEM= -github.com/tecbot/gorocksdb v0.0.0-20191217155057-f0fad39f321c h1:g+WoO5jjkqGAzHWCjJB1zZfXPIAaDpzXIEJ0eS6B5Ok= github.com/tecbot/gorocksdb v0.0.0-20191217155057-f0fad39f321c/go.mod h1:ahpPrc7HpcfEWDQRZEmnXMzHY03mLDYMCxeDzy46i+8= github.com/tendermint/btcd v0.1.1 h1:0VcxPfflS2zZ3RiOAHkBiFUcPvbtRj5O7zHmcJWHV7s= github.com/tendermint/btcd v0.1.1/go.mod h1:DC6/m53jtQzr/NFmMNEu0rxf18/ktVoVtMrnDD5pN+U= @@ -1272,8 +1271,9 @@ github.com/tendermint/go-amino v0.16.0 h1:GyhmgQKvqF82e2oZeuMSp9JTN0N09emoSZlb2l github.com/tendermint/go-amino v0.16.0/go.mod h1:TQU0M1i/ImAo+tYpZi73AU3V/dKeCoMC9Sphe2ZwGME= github.com/tendermint/tendermint v0.35.6 h1:LRUMQNSbwynDHRqhu1X4jXlkMn/mpzq1siP0WlY5DHo= github.com/tendermint/tendermint v0.35.6/go.mod h1:2hAS7fqHf1/XusWqSl5m7MOrXeptvYVeHpkPup/CAJg= -github.com/tendermint/tm-db v0.6.6 h1:EzhaOfR0bdKyATqcd5PNeyeq8r+V4bRPHBfyFdD9kGM= github.com/tendermint/tm-db v0.6.6/go.mod h1:wP8d49A85B7/erz/r4YbKssKw6ylsO/hKtFk7E1aWZI= +github.com/tendermint/tm-db v0.6.7 h1:fE00Cbl0jayAoqlExN6oyQJ7fR/ZtoVOmvPJ//+shu8= +github.com/tendermint/tm-db v0.6.7/go.mod h1:byQDzFkZV1syXr/ReXS808NxA2xvyuuVgXOJ/088L6I= github.com/tenntenn/modver v1.0.1 h1:2klLppGhDgzJrScMpkj9Ujy3rXPUspSjAcev9tSEBgA= github.com/tenntenn/modver v1.0.1/go.mod h1:bePIyQPb7UeioSRkw3Q0XeMhYZSMx9B8ePqg6SAMGH0= github.com/tenntenn/text/transform v0.0.0-20200319021203-7eef512accb3 h1:f+jULpRQGxTSkNYKJ51yaw6ChIqO+Je8UqsTKN/cDag= diff --git a/store/tools/ics23/go.mod b/store/tools/ics23/go.mod index d03e1523aebf..2918a1834713 100644 --- a/store/tools/ics23/go.mod +++ b/store/tools/ics23/go.mod @@ -8,12 +8,13 @@ require ( github.com/cosmos/iavl v0.17.3 github.com/lazyledger/smt v0.2.1-0.20210709230900-03ea40719554 github.com/tendermint/tendermint v0.34.14 - github.com/tendermint/tm-db v0.6.4 + github.com/tendermint/tm-db v0.6.7 ) require ( github.com/DataDog/zstd v1.4.5 // indirect github.com/cespare/xxhash v1.1.0 // indirect + github.com/cosmos/gorocksdb v1.2.0 // indirect github.com/dgraph-io/badger/v2 v2.2007.2 // indirect github.com/dgraph-io/ristretto v0.0.3 // indirect github.com/dgryski/go-farm v0.0.0-20200201041132-a6ae2369ad13 // indirect @@ -28,14 +29,13 @@ require ( github.com/pkg/errors v0.9.1 // indirect github.com/sasha-s/go-deadlock v0.2.1-0.20190427202633-1595213edefa // indirect github.com/syndtr/goleveldb v1.0.1-0.20200815110645-5c35d600f0ca // indirect - github.com/tecbot/gorocksdb v0.0.0-20191217155057-f0fad39f321c // indirect - go.etcd.io/bbolt v1.3.5 // indirect + go.etcd.io/bbolt v1.3.6 // indirect golang.org/x/crypto v0.0.0-20210817164053-32db794688a5 // indirect golang.org/x/net v0.0.0-20210903162142-ad29c8ab022f // indirect golang.org/x/sys v0.0.0-20210903071746-97244b99971b // indirect golang.org/x/text v0.3.6 // indirect google.golang.org/genproto v0.0.0-20210828152312-66f60bf46e71 // indirect - google.golang.org/grpc v1.42.0 // indirect + google.golang.org/grpc v1.44.0 // indirect google.golang.org/protobuf v1.27.1 // indirect ) diff --git a/store/tools/ics23/go.sum b/store/tools/ics23/go.sum index 2655f0cffef2..ec95070e3fcd 100644 --- a/store/tools/ics23/go.sum +++ b/store/tools/ics23/go.sum @@ -172,6 +172,8 @@ github.com/cosmos/cosmos-sdk v0.45.0 h1:DHD+CIRZ+cYgiLXuTEUL/aprnfPsWSwaww/fIZEs github.com/cosmos/cosmos-sdk v0.45.0/go.mod h1:XXS/asyCqWNWkx2rW6pSuen+EVcpAFxq6khrhnZgHaQ= github.com/cosmos/go-bip39 v0.0.0-20180819234021-555e2067c45d/go.mod h1:tSxLoYXyBmiFeKpvmq4dzayMdCjCnu8uqmCysIGBT2Y= github.com/cosmos/go-bip39 v1.0.0/go.mod h1:RNJv0H/pOIVgxw6KS7QeX2a0Uo0aKUlfhZ4xuwvCdJw= +github.com/cosmos/gorocksdb v1.2.0 h1:d0l3jJG8M4hBouIZq0mDUHZ+zjOx044J3nGRskwTb4Y= +github.com/cosmos/gorocksdb v1.2.0/go.mod h1:aaKvKItm514hKfNJpUJXnnOWeBnk2GL4+Qw9NHizILw= github.com/cosmos/iavl v0.17.3 h1:s2N819a2olOmiauVa0WAhoIJq9EhSXE9HDBAoR9k+8Y= github.com/cosmos/iavl v0.17.3/go.mod h1:prJoErZFABYZGDHka1R6Oay4z9PrNeFFiMKHDAMOi4w= github.com/cosmos/ledger-cosmos-go v0.11.1/go.mod h1:J8//BsAGTo3OC/vDLjMRFLW6q0WAaXvHnVc7ZmE8iUY= @@ -226,12 +228,12 @@ github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.m github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021/go.mod h1:AFq3mo9L8Lqqiid3OhADV3RfLJnjiw63cSpi+fDTRC0= github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= github.com/ethereum/go-ethereum v1.9.25/go.mod h1:vMkFiYLHI4tgPw4k2j4MHKoovchFE8plZ0M9VMk4/oM= -github.com/facebookgo/ensure v0.0.0-20160127193407-b4ab57deab51 h1:0JZ+dUmQeA8IIVUMzysrX4/AKuQwWhV2dYQuPZdvdSQ= github.com/facebookgo/ensure v0.0.0-20160127193407-b4ab57deab51/go.mod h1:Yg+htXGokKKdzcwhuNDwVvN+uBxDGXJ7G/VN1d8fa64= +github.com/facebookgo/ensure v0.0.0-20200202191622-63f1cf65ac4c h1:8ISkoahWXwZR41ois5lSJBSVw4D0OV19Ht/JSTzvSv0= github.com/facebookgo/stack v0.0.0-20160209184415-751773369052 h1:JWuenKqqX8nojtoVVWjGfOF9635RETekkoH6Cc9SX0A= github.com/facebookgo/stack v0.0.0-20160209184415-751773369052/go.mod h1:UbMTZqLaRiH3MsBH8va0n7s1pQYcu3uTb8G4tygF4Zg= -github.com/facebookgo/subset v0.0.0-20150612182917-8dac2c3c4870 h1:E2s37DuLxFhQDg5gKsWoLBOB0n+ZW8s599zru8FJ2/Y= github.com/facebookgo/subset v0.0.0-20150612182917-8dac2c3c4870/go.mod h1:5tD+neXqOorC30/tWg0LCSkrqj/AR6gu8yY8/fpw1q0= +github.com/facebookgo/subset v0.0.0-20200203212716-c811ad88dec4 h1:7HZCaLC5+BZpmbhCOZJ293Lz68O7PYrF2EzeiFMwCLk= github.com/fatih/color v1.3.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4= github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4= github.com/fatih/color v1.10.0/go.mod h1:ELkj/draVOlAH/xkhN6mQ50Qd0MPOk5AAr3maGEBuJM= @@ -698,15 +700,15 @@ github.com/subosito/gotenv v1.2.0/go.mod h1:N0PQaV/YGNqwC0u51sEeR/aUtSLEXKX9iv69 github.com/syndtr/gocapability v0.0.0-20200815063812-42c35b437635/go.mod h1:hkRG7XYTFWNJGYcbNJQlaLq0fg1yr4J4t/NcTQtrfww= github.com/syndtr/goleveldb v1.0.1-0.20200815110645-5c35d600f0ca h1:Ld/zXl5t4+D69SiV4JoN7kkfvJdOWlPpfxrzxpLMoUk= github.com/syndtr/goleveldb v1.0.1-0.20200815110645-5c35d600f0ca/go.mod h1:u2MKkTVTVJWe5D1rCvame8WqhBd88EuIwODJZ1VHCPM= -github.com/tecbot/gorocksdb v0.0.0-20191217155057-f0fad39f321c h1:g+WoO5jjkqGAzHWCjJB1zZfXPIAaDpzXIEJ0eS6B5Ok= github.com/tecbot/gorocksdb v0.0.0-20191217155057-f0fad39f321c/go.mod h1:ahpPrc7HpcfEWDQRZEmnXMzHY03mLDYMCxeDzy46i+8= github.com/tendermint/btcd v0.1.1/go.mod h1:DC6/m53jtQzr/NFmMNEu0rxf18/ktVoVtMrnDD5pN+U= github.com/tendermint/crypto v0.0.0-20191022145703-50d29ede1e15/go.mod h1:z4YtwM70uOnk8h0pjJYlj3zdYwi9l03By6iAIF5j/Pk= github.com/tendermint/go-amino v0.16.0/go.mod h1:TQU0M1i/ImAo+tYpZi73AU3V/dKeCoMC9Sphe2ZwGME= github.com/tendermint/tendermint v0.34.14 h1:GCXmlS8Bqd2Ix3TQCpwYLUNHe+Y+QyJsm5YE+S/FkPo= github.com/tendermint/tendermint v0.34.14/go.mod h1:FrwVm3TvsVicI9Z7FlucHV6Znfd5KBc/Lpp69cCwtk0= -github.com/tendermint/tm-db v0.6.4 h1:3N2jlnYQkXNQclQwd/eKV/NzlqPlfK21cpRRIx80XXQ= github.com/tendermint/tm-db v0.6.4/go.mod h1:dptYhIpJ2M5kUuenLr+Yyf3zQOv1SgBZcl8/BmWlMBw= +github.com/tendermint/tm-db v0.6.7 h1:fE00Cbl0jayAoqlExN6oyQJ7fR/ZtoVOmvPJ//+shu8= +github.com/tendermint/tm-db v0.6.7/go.mod h1:byQDzFkZV1syXr/ReXS808NxA2xvyuuVgXOJ/088L6I= github.com/tidwall/gjson v1.6.7/go.mod h1:zeFuBCIqD4sN/gmqBzZ4j7Jd6UcA2Fc56x7QFsv+8fI= github.com/tidwall/match v1.0.3/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM= github.com/tidwall/pretty v1.0.2/go.mod h1:XNkn88O1ChpSDQmQeStsy+sBenx6DDtFZJxhVysOjyk= @@ -737,8 +739,9 @@ github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1 github.com/zondax/hid v0.9.0/go.mod h1:l5wttcP0jwtdLjqjMMWFVEE7d1zO0jvSPA9OPZxWpEM= go.etcd.io/bbolt v1.3.2/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU= go.etcd.io/bbolt v1.3.3/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU= -go.etcd.io/bbolt v1.3.5 h1:XAzx9gjCb0Rxj7EoqcClPD1d5ZBxZJk0jbuoPHenBt0= go.etcd.io/bbolt v1.3.5/go.mod h1:G5EMThwa9y8QZGBClrRx5EY+Yw9kAhnjy3bSjsnlVTQ= +go.etcd.io/bbolt v1.3.6 h1:/ecaJf0sk1l4l6V4awd65v2C3ILy7MSj+s/x1ADCIMU= +go.etcd.io/bbolt v1.3.6/go.mod h1:qXsaaIqmgQH0T+OPdb99Bf+PKfBBQVAdyD6TY9G8XM4= go.etcd.io/etcd v0.0.0-20191023171146-3cf2f69b5738/go.mod h1:dnLIgRNXwCJa5e+c6mIZCrds/GIG4ncV9HhK5PX7jPg= go.etcd.io/etcd/api/v3 v3.5.0/go.mod h1:cbVKeC6lCfl7j/8jBhAK6aIYO9XOjdptoxU/nLQcPvs= go.etcd.io/etcd/client/pkg/v3 v3.5.0/go.mod h1:IJHfcCEKxYu1Os13ZdwCwIUTUVGYTSAM3YSwc9/Ac1g= @@ -958,6 +961,7 @@ golang.org/x/sys v0.0.0-20200814200057-3d37ad5750ed/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20200824131525-c12d262b63d8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200905004654-be1d3432aa8f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200909081042-eff7692f9009/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200923182605-d9f96fdee20d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201015000850-e3ed0017c211/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -1171,8 +1175,9 @@ google.golang.org/grpc v1.36.1/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAG google.golang.org/grpc v1.37.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM= google.golang.org/grpc v1.38.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM= google.golang.org/grpc v1.40.0/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34= -google.golang.org/grpc v1.42.0 h1:XT2/MFpuPFsEX2fWh3YQtHkZ+WYZFQRfaUgLZYj/p6A= google.golang.org/grpc v1.42.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU= +google.golang.org/grpc v1.44.0 h1:weqSxi/TMs1SqFRMHCtBgXRs8k3X39QIDEZ0pRcttUg= +google.golang.org/grpc v1.44.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= From 930f5261296c9ec946c6bfd18e218274a4c28c00 Mon Sep 17 00:00:00 2001 From: Julien Robert Date: Mon, 11 Jul 2022 16:08:18 +0200 Subject: [PATCH 17/37] ci: add new package in dependabot config (#12510) --- .github/dependabot.yml | 163 ++++++++++++++++++++++++++--------------- 1 file changed, 103 insertions(+), 60 deletions(-) diff --git a/.github/dependabot.yml b/.github/dependabot.yml index b2766ba8d185..1e7f43964551 100644 --- a/.github/dependabot.yml +++ b/.github/dependabot.yml @@ -1,62 +1,105 @@ +# Please see the documentation for all configuration options: +# https://help.github.com/github/administering-a-repository/configuration-options-for-dependency-updates + version: 2 updates: -- package-ecosystem: github-actions - directory: "/" - schedule: - interval: daily - open-pull-requests-limit: 10 -- package-ecosystem: npm - directory: "/docs" - schedule: - interval: daily - open-pull-requests-limit: 10 - reviewers: - - fadeev -- package-ecosystem: gomod - directory: "/" - schedule: - interval: daily - open-pull-requests-limit: 10 - labels: - - "A:automerge" - - dependencies -- package-ecosystem: gomod - directory: "/db" - schedule: - interval: daily - open-pull-requests-limit: 10 - labels: - - "A:automerge" - - dependencies -- package-ecosystem: gomod - directory: "/api" - schedule: - interval: daily - open-pull-requests-limit: 10 - labels: - - "A:automerge" - - dependencies -- package-ecosystem: gomod - directory: "/orm" - schedule: - interval: daily - open-pull-requests-limit: 10 - labels: - - "A:automerge" - - dependencies -- package-ecosystem: gomod - directory: "/container" - schedule: - interval: daily - open-pull-requests-limit: 10 - labels: - - "A:automerge" - - dependencies -- package-ecosystem: gomod - directory: "/cosmovisor" - schedule: - interval: daily - open-pull-requests-limit: 10 - labels: - - "A:automerge" - - dependencies + - package-ecosystem: github-actions + directory: "/" + schedule: + interval: daily + open-pull-requests-limit: 10 + + - package-ecosystem: npm + directory: "/docs" + schedule: + interval: daily + open-pull-requests-limit: 10 + + - package-ecosystem: gomod + directory: "/" + schedule: + interval: daily + open-pull-requests-limit: 20 + labels: + - "A:automerge" + - dependencies + - package-ecosystem: gomod + directory: "/db" + schedule: + interval: daily + open-pull-requests-limit: 10 + labels: + - "A:automerge" + - dependencies + - package-ecosystem: gomod + directory: "/api" + schedule: + interval: daily + open-pull-requests-limit: 10 + labels: + - "A:automerge" + - dependencies + - package-ecosystem: gomod + directory: "/orm" + schedule: + interval: daily + open-pull-requests-limit: 10 + labels: + - "A:automerge" + - dependencies + - package-ecosystem: gomod + directory: "/core" + schedule: + interval: daily + open-pull-requests-limit: 10 + labels: + - "A:automerge" + - dependencies + - package-ecosystem: gomod + directory: "/cosmovisor" + schedule: + interval: daily + open-pull-requests-limit: 10 + labels: + - "A:automerge" + - dependencies + - package-ecosystem: gomod + directory: "/depinject" + schedule: + interval: daily + open-pull-requests-limit: 10 + labels: + - "A:automerge" + - dependencies + - package-ecosystem: gomod + directory: "/errors" + schedule: + interval: daily + open-pull-requests-limit: 10 + labels: + - "A:automerge" + - dependencies + - package-ecosystem: gomod + directory: "/math" + schedule: + interval: daily + open-pull-requests-limit: 10 + labels: + - "A:automerge" + - dependencies + - package-ecosystem: gomod + directory: "/client/v2" + schedule: + interval: daily + open-pull-requests-limit: 10 + labels: + - "A:automerge" + - dependencies + - package-ecosystem: gomod + directory: "/store/tools/ics23" + schedule: + interval: daily + open-pull-requests-limit: 10 + labels: + - "A:automerge" + - dependencies From ef6c1be98ae9345fa7801bcc2b9838fdc41be8c7 Mon Sep 17 00:00:00 2001 From: Julien Robert Date: Mon, 11 Jul 2022 17:03:45 +0200 Subject: [PATCH 18/37] fix: temporarily disable tendermint query server integration test (#12513) ## Description This PR disables the tendermint query server integration test so that our CI does not keep timing out. It will be re-enabled with a fix in #12482 --- ### Author Checklist *All items are required. Please add a note to the item if the item is not applicable and please add links to any relevant follow up issues.* I have... - [ ] included the correct [type prefix](https://github.com/commitizen/conventional-commit-types/blob/v3.0.0/index.json) in the PR title - [ ] added `!` to the type prefix if API or client breaking change - [ ] targeted the correct branch (see [PR Targeting](https://github.com/cosmos/cosmos-sdk/blob/main/CONTRIBUTING.md#pr-targeting)) - [ ] provided a link to the relevant issue or specification - [ ] followed the guidelines for [building modules](https://github.com/cosmos/cosmos-sdk/blob/main/docs/building-modules) - [ ] included the necessary unit and integration [tests](https://github.com/cosmos/cosmos-sdk/blob/main/CONTRIBUTING.md#testing) - [ ] added a changelog entry to `CHANGELOG.md` - [ ] included comments for [documenting Go code](https://blog.golang.org/godoc) - [ ] updated the relevant documentation or specification - [ ] reviewed "Files changed" and left comments if necessary - [ ] confirmed all CI checks have passed ### Reviewers Checklist *All items are required. Please add a note if the item is not applicable and please add your handle next to the items reviewed if you only reviewed selected items.* I have... - [ ] confirmed the correct [type prefix](https://github.com/commitizen/conventional-commit-types/blob/v3.0.0/index.json) in the PR title - [ ] confirmed `!` in the type prefix if API or client breaking change - [ ] confirmed all author checklist items have been addressed - [ ] reviewed state machine logic - [ ] reviewed API design and naming - [ ] reviewed documentation is accurate - [ ] reviewed tests and test coverage - [ ] manually tested (if applicable) --- client/grpc/tmservice/service_test.go | 2 ++ 1 file changed, 2 insertions(+) diff --git a/client/grpc/tmservice/service_test.go b/client/grpc/tmservice/service_test.go index 35934f934629..816e171b5a69 100644 --- a/client/grpc/tmservice/service_test.go +++ b/client/grpc/tmservice/service_test.go @@ -25,6 +25,8 @@ type IntegrationTestSuite struct { } func TestIntegrationTestSuite(t *testing.T) { + t.Skip() // to be re-enabled in https://github.com/cosmos/cosmos-sdk/pull/12482/ + suite.Run(t, new(IntegrationTestSuite)) } From 73d50258d723dca88aab435c0fd8fea470fc7556 Mon Sep 17 00:00:00 2001 From: Shi Wenbin Date: Mon, 11 Jul 2022 23:57:08 +0800 Subject: [PATCH 19/37] optimize store.write (#12494) --- store/cachekv/store.go | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/store/cachekv/store.go b/store/cachekv/store.go index 28063504b208..1e7b74ff93a7 100644 --- a/store/cachekv/store.go +++ b/store/cachekv/store.go @@ -101,6 +101,11 @@ func (store *Store) Write() { store.mtx.Lock() defer store.mtx.Unlock() + if len(store.cache) == 0 && len(store.deleted) == 0 && len(store.unsortedCache) == 0 { + store.sortedCache = dbm.NewMemDB() + return + } + // We need a copy of all of the keys. // Not the best, but probably not a bottleneck depending. keys := make([]string, 0, len(store.cache)) From dc1677bdf809fe78667f683ccb90a855d9c6cb6a Mon Sep 17 00:00:00 2001 From: Robert Zaremba Date: Mon, 11 Jul 2022 18:36:58 +0200 Subject: [PATCH 20/37] chore: update gov router note (#12508) ## Description Clarifies the gov router usage in app.go --- ### Author Checklist *All items are required. Please add a note to the item if the item is not applicable and please add links to any relevant follow up issues.* I have... - [ ] included the correct [type prefix](https://github.com/commitizen/conventional-commit-types/blob/v3.0.0/index.json) in the PR title - [ ] added `!` to the type prefix if API or client breaking change - [ ] targeted the correct branch (see [PR Targeting](https://github.com/cosmos/cosmos-sdk/blob/main/CONTRIBUTING.md#pr-targeting)) - [ ] provided a link to the relevant issue or specification - [ ] followed the guidelines for [building modules](https://github.com/cosmos/cosmos-sdk/blob/main/docs/building-modules) - [ ] included the necessary unit and integration [tests](https://github.com/cosmos/cosmos-sdk/blob/main/CONTRIBUTING.md#testing) - [ ] added a changelog entry to `CHANGELOG.md` - [ ] included comments for [documenting Go code](https://blog.golang.org/godoc) - [ ] updated the relevant documentation or specification - [ ] reviewed "Files changed" and left comments if necessary - [ ] confirmed all CI checks have passed ### Reviewers Checklist *All items are required. Please add a note if the item is not applicable and please add your handle next to the items reviewed if you only reviewed selected items.* I have... - [ ] confirmed the correct [type prefix](https://github.com/commitizen/conventional-commit-types/blob/v3.0.0/index.json) in the PR title - [ ] confirmed `!` in the type prefix if API or client breaking change - [ ] confirmed all author checklist items have been addressed - [ ] reviewed state machine logic - [ ] reviewed API design and naming - [ ] reviewed documentation is accurate - [ ] reviewed tests and test coverage - [ ] manually tested (if applicable) --- simapp/app_legacy.go | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/simapp/app_legacy.go b/simapp/app_legacy.go index a093e3222482..4443d13d2c35 100644 --- a/simapp/app_legacy.go +++ b/simapp/app_legacy.go @@ -298,7 +298,10 @@ func NewSimApp( */ app.GroupKeeper = groupkeeper.NewKeeper(keys[group.StoreKey], appCodec, app.MsgServiceRouter(), app.AccountKeeper, groupConfig) - // register the proposal types + // Register the proposal types + // Deprecated: Avoid adding new handlers, instead use the new proposal flow + // by granting the governance module the right to execute the message. + // See: https://github.com/cosmos/cosmos-sdk/blob/release/v0.46.x/x/gov/spec/01_concepts.md#proposal-messages govRouter := govv1beta1.NewRouter() govRouter.AddRoute(govtypes.RouterKey, govv1beta1.ProposalHandler). AddRoute(paramproposal.RouterKey, params.NewParamChangeProposalHandler(app.ParamsKeeper)). From 1815981b021920850dcc04bcebcce1be56de13d8 Mon Sep 17 00:00:00 2001 From: likhita-809 <78951027+likhita-809@users.noreply.github.com> Date: Mon, 11 Jul 2022 22:46:27 +0530 Subject: [PATCH 21/37] feat: deprecate x/params usage in x/auth (#12475) * generate proto files * wip * wip: fix tests * wip: add tests * fix tests * fix tests * add changelog * address review comments * address review comments * add err check for setparams * updates Co-authored-by: Aleksandr Bezobchuk Co-authored-by: Aleksandr Bezobchuk --- CHANGELOG.md | 1 + api/cosmos/auth/v1beta1/genesis.pulsar.go | 2 +- api/cosmos/auth/v1beta1/tx.pulsar.go | 1091 +++++++++++++++++++++ api/cosmos/auth/v1beta1/tx_grpc.pb.go | 113 +++ baseapp/block_gas_test.go | 2 +- contrib/rosetta/rosetta-ci/data.tar.gz | Bin 43673 -> 43328 bytes proto/cosmos/auth/v1beta1/genesis.proto | 2 +- proto/cosmos/auth/v1beta1/tx.proto | 39 + simapp/app.go | 2 +- x/auth/ante/ante_test.go | 8 +- x/auth/ante/sigverify_test.go | 3 +- x/auth/ante/testutil_test.go | 3 +- x/auth/exported/exported.go | 18 + x/auth/keeper/account.go | 14 +- x/auth/keeper/genesis.go | 4 +- x/auth/keeper/grpc_query.go | 2 +- x/auth/keeper/keeper.go | 39 +- x/auth/keeper/keeper_test.go | 5 +- x/auth/keeper/migrations.go | 23 +- x/auth/keeper/msg_server.go | 36 + x/auth/keeper/msg_server_test.go | 111 +++ x/auth/keeper/params.go | 21 +- x/auth/keeper/params_test.go | 92 ++ x/auth/migrations/v043/store_test.go | 44 +- x/auth/migrations/v046/store_test.go | 41 +- x/auth/migrations/v2/migrate.go | 35 + x/auth/migrations/v2/migrator_test.go | 46 + x/auth/module.go | 43 +- x/auth/types/codec.go | 8 + x/auth/types/genesis.pb.go | 2 +- x/auth/types/keys.go | 3 + x/auth/types/msgs.go | 32 + x/auth/types/params.go | 30 - x/auth/types/params_legacy.go | 40 + x/auth/types/tx.pb.go | 603 ++++++++++++ x/bank/keeper/keeper_test.go | 15 +- 36 files changed, 2462 insertions(+), 111 deletions(-) create mode 100644 api/cosmos/auth/v1beta1/tx.pulsar.go create mode 100644 api/cosmos/auth/v1beta1/tx_grpc.pb.go create mode 100644 proto/cosmos/auth/v1beta1/tx.proto create mode 100644 x/auth/exported/exported.go create mode 100644 x/auth/keeper/msg_server.go create mode 100644 x/auth/keeper/msg_server_test.go create mode 100644 x/auth/keeper/params_test.go create mode 100644 x/auth/migrations/v2/migrate.go create mode 100644 x/auth/migrations/v2/migrator_test.go create mode 100644 x/auth/types/msgs.go create mode 100644 x/auth/types/params_legacy.go create mode 100644 x/auth/types/tx.pb.go diff --git a/CHANGELOG.md b/CHANGELOG.md index 3b561e6c9027..06e9ee46bfec 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -56,6 +56,7 @@ Ref: https://keepachangelog.com/en/1.0.0/ ### State Machine Breaking +* (x/auth) [#12475](https://github.com/cosmos/cosmos-sdk/pull/12475) Migrate `x/auth` to self-managed parameters and deprecate its usage of `x/params`. * (x/slashing) [#12399](https://github.com/cosmos/cosmos-sdk/pull/12399) Migrate `x/slashing` to self-managed parameters and deprecate its usage of `x/params`. * (x/mint) [#12363](https://github.com/cosmos/cosmos-sdk/pull/12363) Migrate `x/mint` to self-managed parameters and deprecate it's usage of `x/params`. * (x/distribution) [#12434](https://github.com/cosmos/cosmos-sdk/pull/12434) Migrate `x/distribution` to self-managed parameters and deprecate it's usage of `x/params`. diff --git a/api/cosmos/auth/v1beta1/genesis.pulsar.go b/api/cosmos/auth/v1beta1/genesis.pulsar.go index 9f4af0ae4f73..9aa36a1484cb 100644 --- a/api/cosmos/auth/v1beta1/genesis.pulsar.go +++ b/api/cosmos/auth/v1beta1/genesis.pulsar.go @@ -606,7 +606,7 @@ type GenesisState struct { sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // params defines all the paramaters of the module. + // params defines all the parameters of the module. Params *Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params,omitempty"` // accounts are the accounts present at genesis. Accounts []*anypb.Any `protobuf:"bytes,2,rep,name=accounts,proto3" json:"accounts,omitempty"` diff --git a/api/cosmos/auth/v1beta1/tx.pulsar.go b/api/cosmos/auth/v1beta1/tx.pulsar.go new file mode 100644 index 000000000000..b937cca7832b --- /dev/null +++ b/api/cosmos/auth/v1beta1/tx.pulsar.go @@ -0,0 +1,1091 @@ +// Code generated by protoc-gen-go-pulsar. DO NOT EDIT. +package authv1beta1 + +import ( + _ "cosmossdk.io/api/cosmos/msg/v1" + fmt "fmt" + _ "github.com/cosmos/cosmos-proto" + runtime "github.com/cosmos/cosmos-proto/runtime" + _ "github.com/gogo/protobuf/gogoproto" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoiface "google.golang.org/protobuf/runtime/protoiface" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + io "io" + reflect "reflect" + sync "sync" +) + +var ( + md_MsgUpdateParams protoreflect.MessageDescriptor + fd_MsgUpdateParams_authority protoreflect.FieldDescriptor + fd_MsgUpdateParams_params protoreflect.FieldDescriptor +) + +func init() { + file_cosmos_auth_v1beta1_tx_proto_init() + md_MsgUpdateParams = File_cosmos_auth_v1beta1_tx_proto.Messages().ByName("MsgUpdateParams") + fd_MsgUpdateParams_authority = md_MsgUpdateParams.Fields().ByName("authority") + fd_MsgUpdateParams_params = md_MsgUpdateParams.Fields().ByName("params") +} + +var _ protoreflect.Message = (*fastReflection_MsgUpdateParams)(nil) + +type fastReflection_MsgUpdateParams MsgUpdateParams + +func (x *MsgUpdateParams) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgUpdateParams)(x) +} + +func (x *MsgUpdateParams) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_auth_v1beta1_tx_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_MsgUpdateParams_messageType fastReflection_MsgUpdateParams_messageType +var _ protoreflect.MessageType = fastReflection_MsgUpdateParams_messageType{} + +type fastReflection_MsgUpdateParams_messageType struct{} + +func (x fastReflection_MsgUpdateParams_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgUpdateParams)(nil) +} +func (x fastReflection_MsgUpdateParams_messageType) New() protoreflect.Message { + return new(fastReflection_MsgUpdateParams) +} +func (x fastReflection_MsgUpdateParams_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgUpdateParams +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgUpdateParams) Descriptor() protoreflect.MessageDescriptor { + return md_MsgUpdateParams +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_MsgUpdateParams) Type() protoreflect.MessageType { + return _fastReflection_MsgUpdateParams_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgUpdateParams) New() protoreflect.Message { + return new(fastReflection_MsgUpdateParams) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgUpdateParams) Interface() protoreflect.ProtoMessage { + return (*MsgUpdateParams)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_MsgUpdateParams) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Authority != "" { + value := protoreflect.ValueOfString(x.Authority) + if !f(fd_MsgUpdateParams_authority, value) { + return + } + } + if x.Params != nil { + value := protoreflect.ValueOfMessage(x.Params.ProtoReflect()) + if !f(fd_MsgUpdateParams_params, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_MsgUpdateParams) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "cosmos.auth.v1beta1.MsgUpdateParams.authority": + return x.Authority != "" + case "cosmos.auth.v1beta1.MsgUpdateParams.params": + return x.Params != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.auth.v1beta1.MsgUpdateParams")) + } + panic(fmt.Errorf("message cosmos.auth.v1beta1.MsgUpdateParams does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_MsgUpdateParams) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "cosmos.auth.v1beta1.MsgUpdateParams.authority": + x.Authority = "" + case "cosmos.auth.v1beta1.MsgUpdateParams.params": + x.Params = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.auth.v1beta1.MsgUpdateParams")) + } + panic(fmt.Errorf("message cosmos.auth.v1beta1.MsgUpdateParams does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_MsgUpdateParams) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "cosmos.auth.v1beta1.MsgUpdateParams.authority": + value := x.Authority + return protoreflect.ValueOfString(value) + case "cosmos.auth.v1beta1.MsgUpdateParams.params": + value := x.Params + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.auth.v1beta1.MsgUpdateParams")) + } + panic(fmt.Errorf("message cosmos.auth.v1beta1.MsgUpdateParams does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_MsgUpdateParams) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "cosmos.auth.v1beta1.MsgUpdateParams.authority": + x.Authority = value.Interface().(string) + case "cosmos.auth.v1beta1.MsgUpdateParams.params": + x.Params = value.Message().Interface().(*Params) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.auth.v1beta1.MsgUpdateParams")) + } + panic(fmt.Errorf("message cosmos.auth.v1beta1.MsgUpdateParams does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_MsgUpdateParams) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.auth.v1beta1.MsgUpdateParams.params": + if x.Params == nil { + x.Params = new(Params) + } + return protoreflect.ValueOfMessage(x.Params.ProtoReflect()) + case "cosmos.auth.v1beta1.MsgUpdateParams.authority": + panic(fmt.Errorf("field authority of message cosmos.auth.v1beta1.MsgUpdateParams is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.auth.v1beta1.MsgUpdateParams")) + } + panic(fmt.Errorf("message cosmos.auth.v1beta1.MsgUpdateParams does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_MsgUpdateParams) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.auth.v1beta1.MsgUpdateParams.authority": + return protoreflect.ValueOfString("") + case "cosmos.auth.v1beta1.MsgUpdateParams.params": + m := new(Params) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.auth.v1beta1.MsgUpdateParams")) + } + panic(fmt.Errorf("message cosmos.auth.v1beta1.MsgUpdateParams does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_MsgUpdateParams) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.auth.v1beta1.MsgUpdateParams", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_MsgUpdateParams) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_MsgUpdateParams) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_MsgUpdateParams) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_MsgUpdateParams) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgUpdateParams) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + l = len(x.Authority) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.Params != nil { + l = options.Size(x.Params) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*MsgUpdateParams) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if x.Params != nil { + encoded, err := options.Marshal(x.Params) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x12 + } + if len(x.Authority) > 0 { + i -= len(x.Authority) + copy(dAtA[i:], x.Authority) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Authority))) + i-- + dAtA[i] = 0xa + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*MsgUpdateParams) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUpdateParams: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUpdateParams: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Authority = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Params", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.Params == nil { + x.Params = &Params{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Params); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_MsgUpdateParamsResponse protoreflect.MessageDescriptor +) + +func init() { + file_cosmos_auth_v1beta1_tx_proto_init() + md_MsgUpdateParamsResponse = File_cosmos_auth_v1beta1_tx_proto.Messages().ByName("MsgUpdateParamsResponse") +} + +var _ protoreflect.Message = (*fastReflection_MsgUpdateParamsResponse)(nil) + +type fastReflection_MsgUpdateParamsResponse MsgUpdateParamsResponse + +func (x *MsgUpdateParamsResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgUpdateParamsResponse)(x) +} + +func (x *MsgUpdateParamsResponse) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_auth_v1beta1_tx_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_MsgUpdateParamsResponse_messageType fastReflection_MsgUpdateParamsResponse_messageType +var _ protoreflect.MessageType = fastReflection_MsgUpdateParamsResponse_messageType{} + +type fastReflection_MsgUpdateParamsResponse_messageType struct{} + +func (x fastReflection_MsgUpdateParamsResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgUpdateParamsResponse)(nil) +} +func (x fastReflection_MsgUpdateParamsResponse_messageType) New() protoreflect.Message { + return new(fastReflection_MsgUpdateParamsResponse) +} +func (x fastReflection_MsgUpdateParamsResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgUpdateParamsResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgUpdateParamsResponse) Descriptor() protoreflect.MessageDescriptor { + return md_MsgUpdateParamsResponse +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_MsgUpdateParamsResponse) Type() protoreflect.MessageType { + return _fastReflection_MsgUpdateParamsResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgUpdateParamsResponse) New() protoreflect.Message { + return new(fastReflection_MsgUpdateParamsResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgUpdateParamsResponse) Interface() protoreflect.ProtoMessage { + return (*MsgUpdateParamsResponse)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_MsgUpdateParamsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_MsgUpdateParamsResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.auth.v1beta1.MsgUpdateParamsResponse")) + } + panic(fmt.Errorf("message cosmos.auth.v1beta1.MsgUpdateParamsResponse does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_MsgUpdateParamsResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.auth.v1beta1.MsgUpdateParamsResponse")) + } + panic(fmt.Errorf("message cosmos.auth.v1beta1.MsgUpdateParamsResponse does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_MsgUpdateParamsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.auth.v1beta1.MsgUpdateParamsResponse")) + } + panic(fmt.Errorf("message cosmos.auth.v1beta1.MsgUpdateParamsResponse does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_MsgUpdateParamsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.auth.v1beta1.MsgUpdateParamsResponse")) + } + panic(fmt.Errorf("message cosmos.auth.v1beta1.MsgUpdateParamsResponse does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_MsgUpdateParamsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.auth.v1beta1.MsgUpdateParamsResponse")) + } + panic(fmt.Errorf("message cosmos.auth.v1beta1.MsgUpdateParamsResponse does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_MsgUpdateParamsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.auth.v1beta1.MsgUpdateParamsResponse")) + } + panic(fmt.Errorf("message cosmos.auth.v1beta1.MsgUpdateParamsResponse does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_MsgUpdateParamsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.auth.v1beta1.MsgUpdateParamsResponse", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_MsgUpdateParamsResponse) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_MsgUpdateParamsResponse) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_MsgUpdateParamsResponse) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_MsgUpdateParamsResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgUpdateParamsResponse) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*MsgUpdateParamsResponse) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*MsgUpdateParamsResponse) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUpdateParamsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUpdateParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.27.0 +// protoc (unknown) +// source: cosmos/auth/v1beta1/tx.proto + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// MsgUpdateParams is the Msg/UpdateParams request type. +// +// Since: cosmos-sdk 0.47 +type MsgUpdateParams struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // authority is the address of the governance account. + Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"` + // params defines the x/auth parameters to update. + // + // NOTE: All parameters must be supplied. + Params *Params `protobuf:"bytes,2,opt,name=params,proto3" json:"params,omitempty"` +} + +func (x *MsgUpdateParams) Reset() { + *x = MsgUpdateParams{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_auth_v1beta1_tx_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgUpdateParams) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgUpdateParams) ProtoMessage() {} + +// Deprecated: Use MsgUpdateParams.ProtoReflect.Descriptor instead. +func (*MsgUpdateParams) Descriptor() ([]byte, []int) { + return file_cosmos_auth_v1beta1_tx_proto_rawDescGZIP(), []int{0} +} + +func (x *MsgUpdateParams) GetAuthority() string { + if x != nil { + return x.Authority + } + return "" +} + +func (x *MsgUpdateParams) GetParams() *Params { + if x != nil { + return x.Params + } + return nil +} + +// MsgUpdateParamsResponse defines the response structure for executing a +// MsgUpdateParams message. +// +// Since: cosmos-sdk 0.47 +type MsgUpdateParamsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *MsgUpdateParamsResponse) Reset() { + *x = MsgUpdateParamsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_auth_v1beta1_tx_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgUpdateParamsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgUpdateParamsResponse) ProtoMessage() {} + +// Deprecated: Use MsgUpdateParamsResponse.ProtoReflect.Descriptor instead. +func (*MsgUpdateParamsResponse) Descriptor() ([]byte, []int) { + return file_cosmos_auth_v1beta1_tx_proto_rawDescGZIP(), []int{1} +} + +var File_cosmos_auth_v1beta1_tx_proto protoreflect.FileDescriptor + +var file_cosmos_auth_v1beta1_tx_proto_rawDesc = []byte{ + 0x0a, 0x1c, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x61, 0x75, 0x74, 0x68, 0x2f, 0x76, 0x31, + 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x74, 0x78, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x13, + 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x61, 0x75, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x62, 0x65, + 0x74, 0x61, 0x31, 0x1a, 0x14, 0x67, 0x6f, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, + 0x6f, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x19, 0x63, 0x6f, 0x73, 0x6d, 0x6f, + 0x73, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x17, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x6d, 0x73, 0x67, + 0x2f, 0x76, 0x31, 0x2f, 0x6d, 0x73, 0x67, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x63, + 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x61, 0x75, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, + 0x61, 0x31, 0x2f, 0x61, 0x75, 0x74, 0x68, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x94, 0x01, + 0x0a, 0x0f, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, + 0x73, 0x12, 0x36, 0x0a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, + 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x09, + 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x39, 0x0a, 0x06, 0x70, 0x61, 0x72, + 0x61, 0x6d, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x63, 0x6f, 0x73, 0x6d, + 0x6f, 0x73, 0x2e, 0x61, 0x75, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, + 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x06, 0x70, 0x61, + 0x72, 0x61, 0x6d, 0x73, 0x3a, 0x0e, 0x82, 0xe7, 0xb0, 0x2a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, + 0x72, 0x69, 0x74, 0x79, 0x22, 0x19, 0x0a, 0x17, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, + 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x32, + 0x69, 0x0a, 0x03, 0x4d, 0x73, 0x67, 0x12, 0x62, 0x0a, 0x0c, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, + 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x24, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, + 0x61, 0x75, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4d, 0x73, 0x67, + 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x1a, 0x2c, 0x2e, 0x63, + 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x61, 0x75, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, + 0x61, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, + 0x6d, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0xc2, 0x01, 0x0a, 0x17, 0x63, + 0x6f, 0x6d, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x61, 0x75, 0x74, 0x68, 0x2e, 0x76, + 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x42, 0x07, 0x54, 0x78, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, + 0x01, 0x5a, 0x30, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, + 0x61, 0x70, 0x69, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x61, 0x75, 0x74, 0x68, 0x2f, + 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x3b, 0x61, 0x75, 0x74, 0x68, 0x76, 0x31, 0x62, 0x65, + 0x74, 0x61, 0x31, 0xa2, 0x02, 0x03, 0x43, 0x41, 0x58, 0xaa, 0x02, 0x13, 0x43, 0x6f, 0x73, 0x6d, + 0x6f, 0x73, 0x2e, 0x41, 0x75, 0x74, 0x68, 0x2e, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0xca, + 0x02, 0x13, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x41, 0x75, 0x74, 0x68, 0x5c, 0x56, 0x31, + 0x62, 0x65, 0x74, 0x61, 0x31, 0xe2, 0x02, 0x1f, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x41, + 0x75, 0x74, 0x68, 0x5c, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, + 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x15, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, + 0x3a, 0x3a, 0x41, 0x75, 0x74, 0x68, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x62, + 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_cosmos_auth_v1beta1_tx_proto_rawDescOnce sync.Once + file_cosmos_auth_v1beta1_tx_proto_rawDescData = file_cosmos_auth_v1beta1_tx_proto_rawDesc +) + +func file_cosmos_auth_v1beta1_tx_proto_rawDescGZIP() []byte { + file_cosmos_auth_v1beta1_tx_proto_rawDescOnce.Do(func() { + file_cosmos_auth_v1beta1_tx_proto_rawDescData = protoimpl.X.CompressGZIP(file_cosmos_auth_v1beta1_tx_proto_rawDescData) + }) + return file_cosmos_auth_v1beta1_tx_proto_rawDescData +} + +var file_cosmos_auth_v1beta1_tx_proto_msgTypes = make([]protoimpl.MessageInfo, 2) +var file_cosmos_auth_v1beta1_tx_proto_goTypes = []interface{}{ + (*MsgUpdateParams)(nil), // 0: cosmos.auth.v1beta1.MsgUpdateParams + (*MsgUpdateParamsResponse)(nil), // 1: cosmos.auth.v1beta1.MsgUpdateParamsResponse + (*Params)(nil), // 2: cosmos.auth.v1beta1.Params +} +var file_cosmos_auth_v1beta1_tx_proto_depIdxs = []int32{ + 2, // 0: cosmos.auth.v1beta1.MsgUpdateParams.params:type_name -> cosmos.auth.v1beta1.Params + 0, // 1: cosmos.auth.v1beta1.Msg.UpdateParams:input_type -> cosmos.auth.v1beta1.MsgUpdateParams + 1, // 2: cosmos.auth.v1beta1.Msg.UpdateParams:output_type -> cosmos.auth.v1beta1.MsgUpdateParamsResponse + 2, // [2:3] is the sub-list for method output_type + 1, // [1:2] is the sub-list for method input_type + 1, // [1:1] is the sub-list for extension type_name + 1, // [1:1] is the sub-list for extension extendee + 0, // [0:1] is the sub-list for field type_name +} + +func init() { file_cosmos_auth_v1beta1_tx_proto_init() } +func file_cosmos_auth_v1beta1_tx_proto_init() { + if File_cosmos_auth_v1beta1_tx_proto != nil { + return + } + file_cosmos_auth_v1beta1_auth_proto_init() + if !protoimpl.UnsafeEnabled { + file_cosmos_auth_v1beta1_tx_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgUpdateParams); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cosmos_auth_v1beta1_tx_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgUpdateParamsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_cosmos_auth_v1beta1_tx_proto_rawDesc, + NumEnums: 0, + NumMessages: 2, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_cosmos_auth_v1beta1_tx_proto_goTypes, + DependencyIndexes: file_cosmos_auth_v1beta1_tx_proto_depIdxs, + MessageInfos: file_cosmos_auth_v1beta1_tx_proto_msgTypes, + }.Build() + File_cosmos_auth_v1beta1_tx_proto = out.File + file_cosmos_auth_v1beta1_tx_proto_rawDesc = nil + file_cosmos_auth_v1beta1_tx_proto_goTypes = nil + file_cosmos_auth_v1beta1_tx_proto_depIdxs = nil +} diff --git a/api/cosmos/auth/v1beta1/tx_grpc.pb.go b/api/cosmos/auth/v1beta1/tx_grpc.pb.go new file mode 100644 index 000000000000..61a59ec669a6 --- /dev/null +++ b/api/cosmos/auth/v1beta1/tx_grpc.pb.go @@ -0,0 +1,113 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.2.0 +// - protoc (unknown) +// source: cosmos/auth/v1beta1/tx.proto + +package authv1beta1 + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +// MsgClient is the client API for Msg service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type MsgClient interface { + // UpdateParams defines a governance operation for updating the x/auth module + // parameters. The authority is hard-coded to the x/gov module account. + // + // Since: cosmos-sdk 0.47 + UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) +} + +type msgClient struct { + cc grpc.ClientConnInterface +} + +func NewMsgClient(cc grpc.ClientConnInterface) MsgClient { + return &msgClient{cc} +} + +func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) { + out := new(MsgUpdateParamsResponse) + err := c.cc.Invoke(ctx, "/cosmos.auth.v1beta1.Msg/UpdateParams", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// MsgServer is the server API for Msg service. +// All implementations must embed UnimplementedMsgServer +// for forward compatibility +type MsgServer interface { + // UpdateParams defines a governance operation for updating the x/auth module + // parameters. The authority is hard-coded to the x/gov module account. + // + // Since: cosmos-sdk 0.47 + UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error) + mustEmbedUnimplementedMsgServer() +} + +// UnimplementedMsgServer must be embedded to have forward compatible implementations. +type UnimplementedMsgServer struct { +} + +func (UnimplementedMsgServer) UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateParams not implemented") +} +func (UnimplementedMsgServer) mustEmbedUnimplementedMsgServer() {} + +// UnsafeMsgServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to MsgServer will +// result in compilation errors. +type UnsafeMsgServer interface { + mustEmbedUnimplementedMsgServer() +} + +func RegisterMsgServer(s grpc.ServiceRegistrar, srv MsgServer) { + s.RegisterService(&Msg_ServiceDesc, srv) +} + +func _Msg_UpdateParams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgUpdateParams) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).UpdateParams(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmos.auth.v1beta1.Msg/UpdateParams", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).UpdateParams(ctx, req.(*MsgUpdateParams)) + } + return interceptor(ctx, in, info, handler) +} + +// Msg_ServiceDesc is the grpc.ServiceDesc for Msg service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var Msg_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "cosmos.auth.v1beta1.Msg", + HandlerType: (*MsgServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "UpdateParams", + Handler: _Msg_UpdateParams_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "cosmos/auth/v1beta1/tx.proto", +} diff --git a/baseapp/block_gas_test.go b/baseapp/block_gas_test.go index 747bda83f22a..6351f0f34dbd 100644 --- a/baseapp/block_gas_test.go +++ b/baseapp/block_gas_test.go @@ -124,7 +124,7 @@ func TestBaseApp_BlockGas(t *testing.T) { require.Equal(t, []byte("ok"), okValue) } // check block gas is always consumed - baseGas := uint64(70184) // baseGas is the gas consumed before tx msg + baseGas := uint64(52744) // baseGas is the gas consumed before tx msg expGasConsumed := addUint64Saturating(tc.gasToConsume, baseGas) if expGasConsumed > txtypes.MaxGasWanted { // capped by gasLimit diff --git a/contrib/rosetta/rosetta-ci/data.tar.gz b/contrib/rosetta/rosetta-ci/data.tar.gz index fb05ed31c08174c7b8dff30b281b7872232ebdf9..faad07fe5a93c5efc1df6b0191f08dd0d87e564f 100644 GIT binary patch literal 43328 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 PftAYdqJz4If%^Xdg6js- literal 43673 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 T_n-UE=YReWf;lG>0QLd^t7GmS diff --git a/proto/cosmos/auth/v1beta1/genesis.proto b/proto/cosmos/auth/v1beta1/genesis.proto index c88b94ee4ece..48f068b872eb 100644 --- a/proto/cosmos/auth/v1beta1/genesis.proto +++ b/proto/cosmos/auth/v1beta1/genesis.proto @@ -9,7 +9,7 @@ option go_package = "github.com/cosmos/cosmos-sdk/x/auth/types"; // GenesisState defines the auth module's genesis state. message GenesisState { - // params defines all the paramaters of the module. + // params defines all the parameters of the module. Params params = 1 [(gogoproto.nullable) = false]; // accounts are the accounts present at genesis. diff --git a/proto/cosmos/auth/v1beta1/tx.proto b/proto/cosmos/auth/v1beta1/tx.proto new file mode 100644 index 000000000000..8e3d114b7315 --- /dev/null +++ b/proto/cosmos/auth/v1beta1/tx.proto @@ -0,0 +1,39 @@ +syntax = "proto3"; +package cosmos.auth.v1beta1; + +import "gogoproto/gogo.proto"; +import "cosmos_proto/cosmos.proto"; +import "cosmos/msg/v1/msg.proto"; +import "cosmos/auth/v1beta1/auth.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/x/auth/types"; + +// Msg defines the x/auth Msg service. +service Msg { + // UpdateParams defines a governance operation for updating the x/auth module + // parameters. The authority is hard-coded to the x/gov module account. + // + // Since: cosmos-sdk 0.47 + rpc UpdateParams(MsgUpdateParams) returns (MsgUpdateParamsResponse); +} + +// MsgUpdateParams is the Msg/UpdateParams request type. +// +// Since: cosmos-sdk 0.47 +message MsgUpdateParams { + option (cosmos.msg.v1.signer) = "authority"; + + // authority is the address of the governance account. + string authority = 1 [(cosmos_proto.scalar) = "cosmos.AddressString"]; + + // params defines the x/auth parameters to update. + // + // NOTE: All parameters must be supplied. + Params params = 2 [(gogoproto.nullable) = false]; +} + +// MsgUpdateParamsResponse defines the response structure for executing a +// MsgUpdateParams message. +// +// Since: cosmos-sdk 0.47 +message MsgUpdateParamsResponse {} diff --git a/simapp/app.go b/simapp/app.go index 5c824723688c..34432a1aac98 100644 --- a/simapp/app.go +++ b/simapp/app.go @@ -269,7 +269,7 @@ func NewSimApp( // NOTE: this is not required apps that don't use the simulator for fuzz testing // transactions overrideModules := map[string]module.AppModuleSimulation{ - authtypes.ModuleName: auth.NewAppModule(app.appCodec, app.AccountKeeper, authsims.RandomGenesisAccounts), + authtypes.ModuleName: auth.NewAppModule(app.appCodec, app.AccountKeeper, authsims.RandomGenesisAccounts, app.GetSubspace(authtypes.ModuleName)), } app.sm = module.NewSimulationManagerFromAppModules(app.ModuleManager.Modules, overrideModules) diff --git a/x/auth/ante/ante_test.go b/x/auth/ante/ante_test.go index a3bcc8779e1e..b1327914dff9 100644 --- a/x/auth/ante/ante_test.go +++ b/x/auth/ante/ante_test.go @@ -1116,14 +1116,16 @@ func (suite *AnteTestSuite) TestAnteHandlerReCheck() { } for _, tc := range testCases { // set testcase parameters - suite.accountKeeper.SetParams(suite.ctx, tc.params) + err := suite.accountKeeper.SetParams(suite.ctx, tc.params) + suite.Require().NoError(err) - _, err := suite.anteHandler(suite.ctx, tx, false) + _, err = suite.anteHandler(suite.ctx, tx, false) suite.Require().NotNil(err, "tx does not fail on recheck with updated params in test case: %s", tc.name) // reset parameters to default values - suite.accountKeeper.SetParams(suite.ctx, types.DefaultParams()) + err = suite.accountKeeper.SetParams(suite.ctx, types.DefaultParams()) + suite.Require().NoError(err) } // require that local mempool fee check is still run on recheck since validator may change minFee between check and recheck diff --git a/x/auth/ante/sigverify_test.go b/x/auth/ante/sigverify_test.go index 4f69c40a25b6..faec68228290 100644 --- a/x/auth/ante/sigverify_test.go +++ b/x/auth/ante/sigverify_test.go @@ -319,7 +319,8 @@ func (suite *AnteTestSuite) runSigDecorators(params types.Params, _ bool, privs // Make block-height non-zero to include accNum in SignBytes suite.ctx = suite.ctx.WithBlockHeight(1) - suite.accountKeeper.SetParams(suite.ctx, params) + err := suite.accountKeeper.SetParams(suite.ctx, params) + suite.Require().NoError(err) msgs := make([]sdk.Msg, len(privs)) accNums := make([]uint64, len(privs)) diff --git a/x/auth/ante/testutil_test.go b/x/auth/ante/testutil_test.go index eb5683ea0cfa..5167dac5365f 100644 --- a/x/auth/ante/testutil_test.go +++ b/x/auth/ante/testutil_test.go @@ -73,7 +73,8 @@ func (suite *AnteTestSuite) SetupTest(isCheckTx bool) { suite.Require().NoError(err) suite.ctx = app.BaseApp.NewContext(isCheckTx, tmproto.Header{}).WithBlockHeight(1) - suite.accountKeeper.SetParams(suite.ctx, authtypes.DefaultParams()) + err = suite.accountKeeper.SetParams(suite.ctx, authtypes.DefaultParams()) + suite.Require().NoError(err) // We're using TestMsg encoding in some tests, so register it here. legacyAmino.Amino.RegisterConcrete(&testdata.TestMsg{}, "testdata.TestMsg", nil) diff --git a/x/auth/exported/exported.go b/x/auth/exported/exported.go new file mode 100644 index 000000000000..000114e6194d --- /dev/null +++ b/x/auth/exported/exported.go @@ -0,0 +1,18 @@ +package exported + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" +) + +type ( + ParamSet = paramtypes.ParamSet + + // Subspace defines an interface that implements the legacy x/params Subspace + // type. + // + // NOTE: This is used solely for migration of x/params managed parameters. + Subspace interface { + GetParamSet(ctx sdk.Context, ps ParamSet) + } +) diff --git a/x/auth/keeper/account.go b/x/auth/keeper/account.go index a18a5240dce8..bfa03ea1e608 100644 --- a/x/auth/keeper/account.go +++ b/x/auth/keeper/account.go @@ -27,19 +27,19 @@ func (ak AccountKeeper) NewAccount(ctx sdk.Context, acc types.AccountI) types.Ac // HasAccount implements AccountKeeperI. func (ak AccountKeeper) HasAccount(ctx sdk.Context, addr sdk.AccAddress) bool { - store := ctx.KVStore(ak.key) + store := ctx.KVStore(ak.storeKey) return store.Has(types.AddressStoreKey(addr)) } // HasAccountAddressByID checks account address exists by id. func (ak AccountKeeper) HasAccountAddressByID(ctx sdk.Context, id uint64) bool { - store := ctx.KVStore(ak.key) + store := ctx.KVStore(ak.storeKey) return store.Has(types.AccountNumberStoreKey(id)) } // GetAccount implements AccountKeeperI. func (ak AccountKeeper) GetAccount(ctx sdk.Context, addr sdk.AccAddress) types.AccountI { - store := ctx.KVStore(ak.key) + store := ctx.KVStore(ak.storeKey) bz := store.Get(types.AddressStoreKey(addr)) if bz == nil { return nil @@ -50,7 +50,7 @@ func (ak AccountKeeper) GetAccount(ctx sdk.Context, addr sdk.AccAddress) types.A // GetAccountAddressById returns account address by id. func (ak AccountKeeper) GetAccountAddressByID(ctx sdk.Context, id uint64) string { - store := ctx.KVStore(ak.key) + store := ctx.KVStore(ak.storeKey) bz := store.Get(types.AccountNumberStoreKey(id)) if bz == nil { return "" @@ -71,7 +71,7 @@ func (ak AccountKeeper) GetAllAccounts(ctx sdk.Context) (accounts []types.Accoun // SetAccount implements AccountKeeperI. func (ak AccountKeeper) SetAccount(ctx sdk.Context, acc types.AccountI) { addr := acc.GetAddress() - store := ctx.KVStore(ak.key) + store := ctx.KVStore(ak.storeKey) bz, err := ak.MarshalAccount(acc) if err != nil { @@ -86,7 +86,7 @@ func (ak AccountKeeper) SetAccount(ctx sdk.Context, acc types.AccountI) { // NOTE: this will cause supply invariant violation if called func (ak AccountKeeper) RemoveAccount(ctx sdk.Context, acc types.AccountI) { addr := acc.GetAddress() - store := ctx.KVStore(ak.key) + store := ctx.KVStore(ak.storeKey) store.Delete(types.AddressStoreKey(addr)) store.Delete(types.AccountNumberStoreKey(acc.GetAccountNumber())) } @@ -94,7 +94,7 @@ func (ak AccountKeeper) RemoveAccount(ctx sdk.Context, acc types.AccountI) { // IterateAccounts iterates over all the stored accounts and performs a callback function. // Stops iteration when callback returns true. func (ak AccountKeeper) IterateAccounts(ctx sdk.Context, cb func(account types.AccountI) (stop bool)) { - store := ctx.KVStore(ak.key) + store := ctx.KVStore(ak.storeKey) iterator := sdk.KVStorePrefixIterator(store, types.AddressStoreKeyPrefix) defer iterator.Close() diff --git a/x/auth/keeper/genesis.go b/x/auth/keeper/genesis.go index 50d36381fd6f..44c0af2d3bb8 100644 --- a/x/auth/keeper/genesis.go +++ b/x/auth/keeper/genesis.go @@ -10,7 +10,9 @@ import ( // CONTRACT: old coins from the FeeCollectionKeeper need to be transferred through // a genesis port script to the new fee collector account func (ak AccountKeeper) InitGenesis(ctx sdk.Context, data types.GenesisState) { - ak.SetParams(ctx, data.Params) + if err := ak.SetParams(ctx, data.Params); err != nil { + panic(err) + } accounts, err := types.UnpackAccounts(data.Accounts) if err != nil { diff --git a/x/auth/keeper/grpc_query.go b/x/auth/keeper/grpc_query.go index 9d37a4ecc9f6..58ed7ef32f8b 100644 --- a/x/auth/keeper/grpc_query.go +++ b/x/auth/keeper/grpc_query.go @@ -43,7 +43,7 @@ func (ak AccountKeeper) Accounts(c context.Context, req *types.QueryAccountsRequ } ctx := sdk.UnwrapSDKContext(c) - store := ctx.KVStore(ak.key) + store := ctx.KVStore(ak.storeKey) accountsStore := prefix.NewStore(store, types.AddressStoreKeyPrefix) var accounts []*codectypes.Any diff --git a/x/auth/keeper/keeper.go b/x/auth/keeper/keeper.go index d4e4435e051c..1ab380ef1d53 100644 --- a/x/auth/keeper/keeper.go +++ b/x/auth/keeper/keeper.go @@ -13,7 +13,6 @@ import ( "github.com/cosmos/cosmos-sdk/types/address" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/auth/types" - paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" ) // AccountKeeperI is the interface contract that x/auth's keeper implements. @@ -55,14 +54,17 @@ type AccountKeeperI interface { // AccountKeeper encodes/decodes accounts using the go-amino (binary) // encoding/decoding library. type AccountKeeper struct { - key storetypes.StoreKey - cdc codec.BinaryCodec - paramSubspace paramtypes.Subspace - permAddrs map[string]types.PermissionsForAddress + storeKey storetypes.StoreKey + cdc codec.BinaryCodec + permAddrs map[string]types.PermissionsForAddress // The prototypical AccountI constructor. proto func() types.AccountI addressCdc address.Codec + + // the address capable of executing a MsgUpdateParams message. Typically, this + // should be the x/gov module account. + authority string } var _ AccountKeeperI = &AccountKeeper{} @@ -74,13 +76,9 @@ var _ AccountKeeperI = &AccountKeeper{} // and don't have to fit into any predefined structure. This auth module does not use account permissions internally, though other modules // may use auth.Keeper to access the accounts permissions map. func NewAccountKeeper( - cdc codec.BinaryCodec, key storetypes.StoreKey, paramstore paramtypes.Subspace, proto func() types.AccountI, - maccPerms map[string][]string, bech32Prefix string, + cdc codec.BinaryCodec, storeKey storetypes.StoreKey, proto func() types.AccountI, + maccPerms map[string][]string, bech32Prefix string, authority string, ) AccountKeeper { - // set KeyTable if it has not already been set - if !paramstore.HasKeyTable() { - paramstore = paramstore.WithKeyTable(types.ParamKeyTable()) - } permAddrs := make(map[string]types.PermissionsForAddress) for name, perms := range maccPerms { @@ -90,15 +88,20 @@ func NewAccountKeeper( bech32Codec := newBech32Codec(bech32Prefix) return AccountKeeper{ - key: key, - proto: proto, - cdc: cdc, - paramSubspace: paramstore, - permAddrs: permAddrs, - addressCdc: bech32Codec, + storeKey: storeKey, + proto: proto, + cdc: cdc, + permAddrs: permAddrs, + addressCdc: bech32Codec, + authority: authority, } } +// GetAuthority returns the x/mint module's authority. +func (ak AccountKeeper) GetAuthority() string { + return ak.authority +} + // Logger returns a module-specific logger. func (ak AccountKeeper) Logger(ctx sdk.Context) log.Logger { return ctx.Logger().With("module", "x/"+types.ModuleName) @@ -128,7 +131,7 @@ func (ak AccountKeeper) GetSequence(ctx sdk.Context, addr sdk.AccAddress) (uint6 // If the global account number is not set, it initializes it with value 0. func (ak AccountKeeper) GetNextAccountNumber(ctx sdk.Context) uint64 { var accNumber uint64 - store := ctx.KVStore(ak.key) + store := ctx.KVStore(ak.storeKey) bz := store.Get(types.GlobalAccountNumberKey) if bz == nil { diff --git a/x/auth/keeper/keeper_test.go b/x/auth/keeper/keeper_test.go index e0ff0509b260..8bf9ca3a4504 100644 --- a/x/auth/keeper/keeper_test.go +++ b/x/auth/keeper/keeper_test.go @@ -38,6 +38,7 @@ type KeeperTestSuite struct { legacyAmino *codec.LegacyAmino interfaceRegistry codectypes.InterfaceRegistry accountKeeper keeper.AccountKeeper + msgServer types.MsgServer } func (suite *KeeperTestSuite) SetupTest() { @@ -52,6 +53,7 @@ func (suite *KeeperTestSuite) SetupTest() { suite.app = app suite.ctx = app.BaseApp.NewContext(true, tmproto.Header{}) + suite.msgServer = keeper.NewMsgServerImpl(suite.accountKeeper) queryHelper := baseapp.NewQueryServerTestHelper(suite.ctx, suite.interfaceRegistry) types.RegisterQueryServer(queryHelper, suite.accountKeeper) @@ -129,7 +131,8 @@ func (suite *KeeperTestSuite) TestGetSetParams() { ctx := suite.ctx params := types.DefaultParams() - suite.accountKeeper.SetParams(ctx, params) + err := suite.accountKeeper.SetParams(ctx, params) + suite.Require().NoError(err) actualParams := suite.accountKeeper.GetParams(ctx) suite.Require().Equal(params, actualParams) diff --git a/x/auth/keeper/migrations.go b/x/auth/keeper/migrations.go index 768bc7c10caa..5826a6bb1688 100644 --- a/x/auth/keeper/migrations.go +++ b/x/auth/keeper/migrations.go @@ -6,20 +6,23 @@ import ( v043 "github.com/cosmos/cosmos-sdk/x/auth/migrations/v043" v046 "github.com/cosmos/cosmos-sdk/x/auth/migrations/v046" + "github.com/cosmos/cosmos-sdk/x/auth/exported" "github.com/cosmos/cosmos-sdk/x/auth/types" sdk "github.com/cosmos/cosmos-sdk/types" + v2 "github.com/cosmos/cosmos-sdk/x/auth/migrations/v2" ) // Migrator is a struct for handling in-place store migrations. type Migrator struct { - keeper AccountKeeper - queryServer grpc.Server + keeper AccountKeeper + queryServer grpc.Server + legacySubspace exported.Subspace } // NewMigrator returns a new Migrator. -func NewMigrator(keeper AccountKeeper, queryServer grpc.Server) Migrator { - return Migrator{keeper: keeper, queryServer: queryServer} +func NewMigrator(keeper AccountKeeper, queryServer grpc.Server, ss exported.Subspace) Migrator { + return Migrator{keeper: keeper, queryServer: queryServer, legacySubspace: ss} } // Migrate1to2 migrates from version 1 to 2. @@ -47,7 +50,15 @@ func (m Migrator) Migrate1to2(ctx sdk.Context) error { // Migrate2to3 migrates from consensus version 2 to version 3. Specifically, for each account // we index the account's ID to their address. func (m Migrator) Migrate2to3(ctx sdk.Context) error { - return v046.MigrateStore(ctx, m.keeper.key, m.keeper.cdc) + return v046.MigrateStore(ctx, m.keeper.storeKey, m.keeper.cdc) +} + +// Migrate3to4 migrates the x/auth module state from the consensus version 3 to +// version 4. Specifically, it takes the parameters that are currently stored +// and managed by the x/params modules and stores them directly into the x/auth +// module state. +func (m Migrator) Migrate3to4(ctx sdk.Context) error { + return v2.Migrate(ctx, ctx.KVStore(m.keeper.storeKey), m.legacySubspace, m.keeper.cdc) } // V45_SetAccount implements V45_SetAccount @@ -56,7 +67,7 @@ func (m Migrator) Migrate2to3(ctx sdk.Context) error { // NOTE: This is used for testing purposes only. func (m Migrator) V45_SetAccount(ctx sdk.Context, acc types.AccountI) error { addr := acc.GetAddress() - store := ctx.KVStore(m.keeper.key) + store := ctx.KVStore(m.keeper.storeKey) bz, err := m.keeper.MarshalAccount(acc) if err != nil { diff --git a/x/auth/keeper/msg_server.go b/x/auth/keeper/msg_server.go new file mode 100644 index 000000000000..b79d8cbacc33 --- /dev/null +++ b/x/auth/keeper/msg_server.go @@ -0,0 +1,36 @@ +package keeper + +import ( + "context" + + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/errors" + "github.com/cosmos/cosmos-sdk/x/auth/types" + govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" +) + +var _ types.MsgServer = msgServer{} + +type msgServer struct { + AccountKeeper +} + +// NewMsgServerImpl returns an implementation of the x/auth MsgServer interface. +func NewMsgServerImpl(ak AccountKeeper) types.MsgServer { + return &msgServer{ + AccountKeeper: ak, + } +} + +func (ms msgServer) UpdateParams(goCtx context.Context, req *types.MsgUpdateParams) (*types.MsgUpdateParamsResponse, error) { + if ms.authority != req.Authority { + return nil, errors.Wrapf(govtypes.ErrInvalidSigner, "invalid authority; expected %s, got %s", ms.authority, req.Authority) + } + + ctx := sdk.UnwrapSDKContext(goCtx) + if err := ms.SetParams(ctx, req.Params); err != nil { + return nil, err + } + + return &types.MsgUpdateParamsResponse{}, nil +} diff --git a/x/auth/keeper/msg_server_test.go b/x/auth/keeper/msg_server_test.go new file mode 100644 index 000000000000..03b923d4507c --- /dev/null +++ b/x/auth/keeper/msg_server_test.go @@ -0,0 +1,111 @@ +package keeper_test + +import ( + "github.com/cosmos/cosmos-sdk/x/auth/types" +) + +func (s *KeeperTestSuite) TestUpdateParams() { + testCases := []struct { + name string + req *types.MsgUpdateParams + expectErr bool + expErrMsg string + }{ + { + name: "set invalid authority", + req: &types.MsgUpdateParams{ + Authority: "foo", + }, + expectErr: true, + expErrMsg: "invalid authority", + }, + { + name: "set invalid max memo characters", + req: &types.MsgUpdateParams{ + Authority: s.accountKeeper.GetAuthority(), + Params: types.Params{ + MaxMemoCharacters: 0, + TxSigLimit: 9, + TxSizeCostPerByte: 5, + SigVerifyCostED25519: 694, + SigVerifyCostSecp256k1: 511, + }, + }, + expectErr: true, + expErrMsg: "invalid max memo characters", + }, + { + name: "set invalid tx sig limit", + req: &types.MsgUpdateParams{ + Authority: s.accountKeeper.GetAuthority(), + Params: types.Params{ + MaxMemoCharacters: 140, + TxSigLimit: 0, + TxSizeCostPerByte: 5, + SigVerifyCostED25519: 694, + SigVerifyCostSecp256k1: 511, + }, + }, + expectErr: true, + expErrMsg: "invalid tx signature limit", + }, + { + name: "set invalid tx size cost per bytes", + req: &types.MsgUpdateParams{ + Authority: s.accountKeeper.GetAuthority(), + Params: types.Params{ + MaxMemoCharacters: 140, + TxSigLimit: 9, + TxSizeCostPerByte: 0, + SigVerifyCostED25519: 694, + SigVerifyCostSecp256k1: 511, + }, + }, + expectErr: true, + expErrMsg: "invalid tx size cost per byte", + }, + { + name: "set invalid sig verify cost ED25519", + req: &types.MsgUpdateParams{ + Authority: s.accountKeeper.GetAuthority(), + Params: types.Params{ + MaxMemoCharacters: 140, + TxSigLimit: 9, + TxSizeCostPerByte: 5, + SigVerifyCostED25519: 0, + SigVerifyCostSecp256k1: 511, + }, + }, + expectErr: true, + expErrMsg: "invalid ED25519 signature verification cost", + }, + { + name: "set invalid sig verify cost Secp256k1", + req: &types.MsgUpdateParams{ + Authority: s.accountKeeper.GetAuthority(), + Params: types.Params{ + MaxMemoCharacters: 140, + TxSigLimit: 9, + TxSizeCostPerByte: 5, + SigVerifyCostED25519: 694, + SigVerifyCostSecp256k1: 0, + }, + }, + expectErr: true, + expErrMsg: "invalid SECK256k1 signature verification cost", + }, + } + + for _, tc := range testCases { + tc := tc + s.Run(tc.name, func() { + _, err := s.msgServer.UpdateParams(s.ctx, tc.req) + if tc.expectErr { + s.Require().Error(err) + s.Require().Contains(err.Error(), tc.expErrMsg) + } else { + s.Require().NoError(err) + } + }) + } +} diff --git a/x/auth/keeper/params.go b/x/auth/keeper/params.go index 0236c7ae1627..680f7c1583e2 100644 --- a/x/auth/keeper/params.go +++ b/x/auth/keeper/params.go @@ -6,12 +6,25 @@ import ( ) // SetParams sets the auth module's parameters. -func (ak AccountKeeper) SetParams(ctx sdk.Context, params types.Params) { - ak.paramSubspace.SetParamSet(ctx, ¶ms) +func (ak AccountKeeper) SetParams(ctx sdk.Context, params types.Params) error { + if err := params.Validate(); err != nil { + return err + } + + store := ctx.KVStore(ak.storeKey) + bz := ak.cdc.MustMarshal(¶ms) + store.Set(types.ParamsKey, bz) + + return nil } // GetParams gets the auth module's parameters. func (ak AccountKeeper) GetParams(ctx sdk.Context) (params types.Params) { - ak.paramSubspace.GetParamSet(ctx, ¶ms) - return + store := ctx.KVStore(ak.storeKey) + bz := store.Get(types.ParamsKey) + if bz == nil { + return params + } + ak.cdc.MustUnmarshal(bz, ¶ms) + return params } diff --git a/x/auth/keeper/params_test.go b/x/auth/keeper/params_test.go new file mode 100644 index 000000000000..4853fe563482 --- /dev/null +++ b/x/auth/keeper/params_test.go @@ -0,0 +1,92 @@ +package keeper_test + +import ( + "github.com/cosmos/cosmos-sdk/x/auth/types" +) + +func (s *KeeperTestSuite) TestParams() { + testCases := []struct { + name string + input types.Params + expectErr bool + expErrMsg string + }{ + { + name: "set invalid max memo characters", + input: types.Params{ + MaxMemoCharacters: 0, + TxSigLimit: 9, + TxSizeCostPerByte: 5, + SigVerifyCostED25519: 694, + SigVerifyCostSecp256k1: 511, + }, + expectErr: true, + expErrMsg: "invalid max memo characters", + }, + { + name: "set invalid tx sig limit", + input: types.Params{ + MaxMemoCharacters: 140, + TxSigLimit: 0, + TxSizeCostPerByte: 5, + SigVerifyCostED25519: 694, + SigVerifyCostSecp256k1: 511, + }, + expectErr: true, + expErrMsg: "invalid tx signature limit", + }, + { + name: "set invalid tx size cost per bytes", + input: types.Params{ + MaxMemoCharacters: 140, + TxSigLimit: 9, + TxSizeCostPerByte: 0, + SigVerifyCostED25519: 694, + SigVerifyCostSecp256k1: 511, + }, + expectErr: true, + expErrMsg: "invalid tx size cost per byte", + }, + { + name: "set invalid sig verify cost ED25519", + input: types.Params{ + MaxMemoCharacters: 140, + TxSigLimit: 9, + TxSizeCostPerByte: 5, + SigVerifyCostED25519: 0, + SigVerifyCostSecp256k1: 511, + }, + expectErr: true, + expErrMsg: "invalid ED25519 signature verification cost", + }, + { + name: "set invalid sig verify cost Secp256k1", + input: types.Params{ + MaxMemoCharacters: 140, + TxSigLimit: 9, + TxSizeCostPerByte: 5, + SigVerifyCostED25519: 694, + SigVerifyCostSecp256k1: 0, + }, + expectErr: true, + expErrMsg: "invalid SECK256k1 signature verification cost", + }, + } + for _, tc := range testCases { + tc := tc + s.Run(tc.name, func() { + expected := s.accountKeeper.GetParams(s.ctx) + err := s.accountKeeper.SetParams(s.ctx, tc.input) + if tc.expectErr { + s.Require().Error(err) + s.Require().Contains(err.Error(), tc.expErrMsg) + } else { + expected = tc.input + s.Require().NoError(err) + } + + params := s.accountKeeper.GetParams(s.ctx) + s.Require().Equal(expected, params) + }) + } +} diff --git a/x/auth/migrations/v043/store_test.go b/x/auth/migrations/v043/store_test.go index afd2b9a67d82..afb89bbe2910 100644 --- a/x/auth/migrations/v043/store_test.go +++ b/x/auth/migrations/v043/store_test.go @@ -10,10 +10,15 @@ import ( bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper" + "github.com/cosmos/cosmos-sdk/testutil" simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims" sdk "github.com/cosmos/cosmos-sdk/types" + moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil" + "github.com/cosmos/cosmos-sdk/x/auth" + authexported "github.com/cosmos/cosmos-sdk/x/auth/exported" "github.com/cosmos/cosmos-sdk/x/auth/keeper" - "github.com/cosmos/cosmos-sdk/x/auth/testutil" + v2 "github.com/cosmos/cosmos-sdk/x/auth/migrations/v2" + authtestutil "github.com/cosmos/cosmos-sdk/x/auth/testutil" authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" "github.com/cosmos/cosmos-sdk/x/auth/vesting/exported" "github.com/cosmos/cosmos-sdk/x/auth/vesting/types" @@ -22,21 +27,44 @@ import ( stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" ) +type mockSubspace struct { + ps authtypes.Params +} + +func newMockSubspace(ps authtypes.Params) mockSubspace { + return mockSubspace{ps: ps} +} + +func (ms mockSubspace) GetParamSet(ctx sdk.Context, ps authexported.ParamSet) { + *ps.(*authtypes.Params) = ms.ps +} + func TestMigrateVestingAccounts(t *testing.T) { + encCfg := moduletestutil.MakeTestEncodingConfig(auth.AppModuleBasic{}) + cdc := encCfg.Codec + + storeKey := sdk.NewKVStoreKey(v2.ModuleName) + tKey := sdk.NewTransientStoreKey("transient_test") + ctx := testutil.DefaultContext(storeKey, tKey) + store := ctx.KVStore(storeKey) + var ( accountKeeper keeper.AccountKeeper bankKeeper bankkeeper.Keeper stakingKeeper *stakingkeeper.Keeper ) app, err := simtestutil.Setup( - testutil.AppConfig, + authtestutil.AppConfig, &accountKeeper, &bankKeeper, &stakingKeeper, ) require.NoError(t, err) - ctx := app.BaseApp.NewContext(false, tmproto.Header{Time: time.Now()}) + legacySubspace := newMockSubspace(authtypes.DefaultParams()) + require.NoError(t, v2.Migrate(ctx, store, legacySubspace, cdc)) + + ctx = app.BaseApp.NewContext(false, tmproto.Header{Time: time.Now()}) stakingKeeper.SetParams(ctx, stakingtypes.DefaultParams()) testCases := []struct { @@ -58,7 +86,9 @@ func TestMigrateVestingAccounts(t *testing.T) { ctx = ctx.WithBlockTime(ctx.BlockTime().AddDate(1, 0, 0)) - accountKeeper.SetParams(ctx, authtypes.DefaultParams()) + err := accountKeeper.SetParams(ctx, authtypes.DefaultParams()) + require.NoError(t, err) + accountKeeper.SetAccount(ctx, delayedAccount) _, err = stakingKeeper.Delegate(ctx, delegatorAddr, sdk.NewInt(100), stakingtypes.Unbonded, validator, true) @@ -562,7 +592,9 @@ func TestMigrateVestingAccounts(t *testing.T) { tc := tc t.Run(tc.name, func(t *testing.T) { - accountKeeper.SetParams(ctx, authtypes.DefaultParams()) + err := accountKeeper.SetParams(ctx, authtypes.DefaultParams()) + require.NoError(t, err) + addrs := simtestutil.AddTestAddrs(bankKeeper, stakingKeeper, ctx, 1, sdk.NewInt(tc.tokenAmount)) delegatorAddr := addrs[0] @@ -582,7 +614,7 @@ func TestMigrateVestingAccounts(t *testing.T) { require.True(t, ok) require.NoError(t, tc.garbageFunc(ctx, vestingAccount, accountKeeper)) - m := keeper.NewMigrator(accountKeeper, app.GRPCQueryRouter()) + m := keeper.NewMigrator(accountKeeper, app.GRPCQueryRouter(), legacySubspace) require.NoError(t, m.Migrate1to2(ctx)) var expVested sdk.Coins diff --git a/x/auth/migrations/v046/store_test.go b/x/auth/migrations/v046/store_test.go index 13db36689ac4..e063fac55653 100644 --- a/x/auth/migrations/v046/store_test.go +++ b/x/auth/migrations/v046/store_test.go @@ -6,36 +6,65 @@ import ( "time" "github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1" + "github.com/cosmos/cosmos-sdk/testutil" simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims" + "github.com/cosmos/cosmos-sdk/x/auth" "github.com/cosmos/cosmos-sdk/x/auth/keeper" - "github.com/cosmos/cosmos-sdk/x/auth/testutil" + v2 "github.com/cosmos/cosmos-sdk/x/auth/migrations/v2" + authtestutil "github.com/cosmos/cosmos-sdk/x/auth/testutil" + authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" - "github.com/cosmos/cosmos-sdk/x/auth/types" + sdk "github.com/cosmos/cosmos-sdk/types" + moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil" + authexported "github.com/cosmos/cosmos-sdk/x/auth/exported" "github.com/stretchr/testify/require" tmproto "github.com/tendermint/tendermint/proto/tendermint/types" ) +type mockSubspace struct { + ps authtypes.Params +} + +func newMockSubspace(ps authtypes.Params) mockSubspace { + return mockSubspace{ps: ps} +} + +func (ms mockSubspace) GetParamSet(ctx sdk.Context, ps authexported.ParamSet) { + *ps.(*authtypes.Params) = ms.ps +} + // TestMigrateMapAccAddressToAccNumberKey test cases for state migration of map to accAddr to accNum func TestMigrateMapAccAddressToAccNumberKey(t *testing.T) { + encCfg := moduletestutil.MakeTestEncodingConfig(auth.AppModuleBasic{}) + cdc := encCfg.Codec + + storeKey := sdk.NewKVStoreKey(v2.ModuleName) + tKey := sdk.NewTransientStoreKey("transient_test") + ctx := testutil.DefaultContext(storeKey, tKey) + store := ctx.KVStore(storeKey) + var ( accountKeeper keeper.AccountKeeper ) app, err := simtestutil.Setup( - testutil.AppConfig, + authtestutil.AppConfig, &accountKeeper, ) require.NoError(t, err) + legacySubspace := newMockSubspace(authtypes.DefaultParams()) + require.NoError(t, v2.Migrate(ctx, store, legacySubspace, cdc)) + // new base account senderPrivKey := secp256k1.GenPrivKey() randAccNumber := uint64(rand.Intn(100000-10000) + 10000) - acc := types.NewBaseAccount(senderPrivKey.PubKey().Address().Bytes(), senderPrivKey.PubKey(), randAccNumber, 0) + acc := authtypes.NewBaseAccount(senderPrivKey.PubKey().Address().Bytes(), senderPrivKey.PubKey(), randAccNumber, 0) - ctx := app.BaseApp.NewContext(false, tmproto.Header{Time: time.Now()}) + ctx = app.BaseApp.NewContext(false, tmproto.Header{Time: time.Now()}) // migrator - m := keeper.NewMigrator(accountKeeper, app.GRPCQueryRouter()) + m := keeper.NewMigrator(accountKeeper, app.GRPCQueryRouter(), legacySubspace) // set the account to store with map acc addr to acc number require.NoError(t, m.V45_SetAccount(ctx, acc)) diff --git a/x/auth/migrations/v2/migrate.go b/x/auth/migrations/v2/migrate.go new file mode 100644 index 000000000000..7c5a2b2f38d0 --- /dev/null +++ b/x/auth/migrations/v2/migrate.go @@ -0,0 +1,35 @@ +package v2 + +import ( + "github.com/cosmos/cosmos-sdk/codec" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/auth/exported" + "github.com/cosmos/cosmos-sdk/x/auth/types" +) + +const ( + ModuleName = "auth" +) + +var ( + ParamsKey = []byte{0x01} +) + +// Migrate migrates the x/auth module state from the consensus version 3 to +// version 4. Specifically, it takes the parameters that are currently stored +// and managed by the x/params modules and stores them directly into the x/auth +// module state. +func Migrate(ctx sdk.Context, store sdk.KVStore, legacySubspace exported.Subspace, cdc codec.BinaryCodec) error { + var currParams types.Params + legacySubspace.GetParamSet(ctx, &currParams) + + if err := currParams.Validate(); err != nil { + return err + } + + bz := cdc.MustMarshal(&currParams) + store.Set(ParamsKey, bz) + + return nil + +} diff --git a/x/auth/migrations/v2/migrator_test.go b/x/auth/migrations/v2/migrator_test.go new file mode 100644 index 000000000000..76a5389e7e95 --- /dev/null +++ b/x/auth/migrations/v2/migrator_test.go @@ -0,0 +1,46 @@ +package v2_test + +import ( + "testing" + + "github.com/stretchr/testify/require" + + "github.com/cosmos/cosmos-sdk/testutil" + sdk "github.com/cosmos/cosmos-sdk/types" + + moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil" + "github.com/cosmos/cosmos-sdk/x/auth" + "github.com/cosmos/cosmos-sdk/x/auth/exported" + v2 "github.com/cosmos/cosmos-sdk/x/auth/migrations/v2" + "github.com/cosmos/cosmos-sdk/x/auth/types" +) + +type mockSubspace struct { + ps types.Params +} + +func newMockSubspace(ps types.Params) mockSubspace { + return mockSubspace{ps: ps} +} + +func (ms mockSubspace) GetParamSet(ctx sdk.Context, ps exported.ParamSet) { + *ps.(*types.Params) = ms.ps +} + +func TestMigrate(t *testing.T) { + encCfg := moduletestutil.MakeTestEncodingConfig(auth.AppModuleBasic{}) + cdc := encCfg.Codec + + storeKey := sdk.NewKVStoreKey(v2.ModuleName) + tKey := sdk.NewTransientStoreKey("transient_test") + ctx := testutil.DefaultContext(storeKey, tKey) + store := ctx.KVStore(storeKey) + + legacySubspace := newMockSubspace(types.DefaultParams()) + require.NoError(t, v2.Migrate(ctx, store, legacySubspace, cdc)) + + var res types.Params + bz := store.Get(v2.ParamsKey) + require.NoError(t, cdc.Unmarshal(bz, &res)) + require.Equal(t, legacySubspace.ps, res) +} diff --git a/x/auth/module.go b/x/auth/module.go index 8b1885aa67ac..c72e76848ea2 100644 --- a/x/auth/module.go +++ b/x/auth/module.go @@ -17,7 +17,6 @@ import ( "cosmossdk.io/core/appmodule" "github.com/cosmos/cosmos-sdk/runtime" store "github.com/cosmos/cosmos-sdk/store/types" - paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/codec" @@ -26,11 +25,16 @@ import ( "github.com/cosmos/cosmos-sdk/types/module" simtypes "github.com/cosmos/cosmos-sdk/types/simulation" "github.com/cosmos/cosmos-sdk/x/auth/client/cli" + "github.com/cosmos/cosmos-sdk/x/auth/exported" "github.com/cosmos/cosmos-sdk/x/auth/keeper" "github.com/cosmos/cosmos-sdk/x/auth/simulation" "github.com/cosmos/cosmos-sdk/x/auth/types" + govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" ) +// ConsensusVersion defines the current x/auth module consensus version. +const ConsensusVersion = 4 + var ( _ module.AppModule = AppModule{} _ module.AppModuleBasic = AppModuleBasic{} @@ -94,14 +98,18 @@ type AppModule struct { accountKeeper keeper.AccountKeeper randGenAccountsFn types.RandomGenesisAccountsFn + + // legacySubspace is used solely for migration of x/params managed parameters + legacySubspace exported.Subspace } // NewAppModule creates a new AppModule object -func NewAppModule(cdc codec.Codec, accountKeeper keeper.AccountKeeper, randGenAccountsFn types.RandomGenesisAccountsFn) AppModule { +func NewAppModule(cdc codec.Codec, accountKeeper keeper.AccountKeeper, randGenAccountsFn types.RandomGenesisAccountsFn, ss exported.Subspace) AppModule { return AppModule{ AppModuleBasic: AppModuleBasic{}, accountKeeper: accountKeeper, randGenAccountsFn: randGenAccountsFn, + legacySubspace: ss, } } @@ -131,17 +139,20 @@ func (am AppModule) LegacyQuerierHandler(legacyQuerierCdc *codec.LegacyAmino) sd // RegisterServices registers a GRPC query service to respond to the // module-specific GRPC queries. func (am AppModule) RegisterServices(cfg module.Configurator) { + types.RegisterMsgServer(cfg.MsgServer(), keeper.NewMsgServerImpl(am.accountKeeper)) types.RegisterQueryServer(cfg.QueryServer(), am.accountKeeper) - m := keeper.NewMigrator(am.accountKeeper, cfg.QueryServer()) - err := cfg.RegisterMigration(types.ModuleName, 1, m.Migrate1to2) - if err != nil { + m := keeper.NewMigrator(am.accountKeeper, cfg.QueryServer(), am.legacySubspace) + if err := cfg.RegisterMigration(types.ModuleName, 1, m.Migrate1to2); err != nil { panic(err) } - err = cfg.RegisterMigration(types.ModuleName, 2, m.Migrate2to3) - if err != nil { + if err := cfg.RegisterMigration(types.ModuleName, 2, m.Migrate2to3); err != nil { panic(err) } + + if err := cfg.RegisterMigration(types.ModuleName, 3, m.Migrate3to4); err != nil { + panic(fmt.Sprintf("failed to migrate x/%s from version 3 to 4: %v", types.ModuleName, err)) + } } // InitGenesis performs genesis initialization for the auth module. It returns @@ -161,7 +172,7 @@ func (am AppModule) ExportGenesis(ctx sdk.Context, cdc codec.JSONCodec) json.Raw } // ConsensusVersion implements AppModule/ConsensusVersion. -func (AppModule) ConsensusVersion() uint64 { return 3 } +func (AppModule) ConsensusVersion() uint64 { return ConsensusVersion } // BeginBlock returns the begin blocker for the auth module. func (AppModule) BeginBlock(_ sdk.Context, _ abci.RequestBeginBlock) {} @@ -186,7 +197,7 @@ func (AppModule) ProposalContents(simState module.SimulationState) []simtypes.We // RandomizedParams creates randomized auth param changes for the simulator. func (AppModule) RandomizedParams(r *rand.Rand) []simtypes.ParamChange { - return simulation.ParamChanges(r) + return []simtypes.ParamChange{} } // RegisterStoreDecoder registers a decoder for auth module's types @@ -216,10 +227,12 @@ func provideModuleBasic() runtime.AppModuleBasicWrapper { type authInputs struct { depinject.In - Config *modulev1.Module - Key *store.KVStoreKey - Cdc codec.Codec - Subspace paramtypes.Subspace + Config *modulev1.Module + Key *store.KVStoreKey + Cdc codec.Codec + + // LegacySubspace is used solely for migration of x/params managed parameters + LegacySubspace exported.Subspace } type authOutputs struct { @@ -235,8 +248,8 @@ func provideModule(in authInputs) authOutputs { maccPerms[permission.Account] = permission.Permissions } - k := keeper.NewAccountKeeper(in.Cdc, in.Key, in.Subspace, types.ProtoBaseAccount, maccPerms, in.Config.Bech32Prefix) - m := NewAppModule(in.Cdc, k, simulation.RandomGenesisAccounts) + k := keeper.NewAccountKeeper(in.Cdc, in.Key, types.ProtoBaseAccount, maccPerms, in.Config.Bech32Prefix, types.NewModuleAddress(govtypes.ModuleName).String()) + m := NewAppModule(in.Cdc, k, simulation.RandomGenesisAccounts, in.LegacySubspace) return authOutputs{AccountKeeper: k, Module: runtime.WrapAppModule(m)} } diff --git a/x/auth/types/codec.go b/x/auth/types/codec.go index 29561dfe018c..020fa7c0d9c3 100644 --- a/x/auth/types/codec.go +++ b/x/auth/types/codec.go @@ -2,6 +2,7 @@ package types import ( "github.com/cosmos/cosmos-sdk/codec" + "github.com/cosmos/cosmos-sdk/codec/legacy" "github.com/cosmos/cosmos-sdk/codec/types" cryptocodec "github.com/cosmos/cosmos-sdk/crypto/codec" sdk "github.com/cosmos/cosmos-sdk/types" @@ -17,6 +18,9 @@ func RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) { cdc.RegisterInterface((*AccountI)(nil), nil) cdc.RegisterConcrete(&BaseAccount{}, "cosmos-sdk/BaseAccount", nil) cdc.RegisterConcrete(&ModuleAccount{}, "cosmos-sdk/ModuleAccount", nil) + cdc.RegisterConcrete(Params{}, "cosmos-sdk/x/auth/Params", nil) + + legacy.RegisterAminoMsg(cdc, &MsgUpdateParams{}, "cosmos-sdk/x/auth/MsgUpdateParams") legacytx.RegisterLegacyAminoCodec(cdc) } @@ -37,6 +41,10 @@ func RegisterInterfaces(registry types.InterfaceRegistry) { &BaseAccount{}, &ModuleAccount{}, ) + + registry.RegisterImplementations((*sdk.Msg)(nil), + &MsgUpdateParams{}, + ) } var ( diff --git a/x/auth/types/genesis.pb.go b/x/auth/types/genesis.pb.go index 4e7396ab7cb3..aadea95e72cf 100644 --- a/x/auth/types/genesis.pb.go +++ b/x/auth/types/genesis.pb.go @@ -26,7 +26,7 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package // GenesisState defines the auth module's genesis state. type GenesisState struct { - // params defines all the paramaters of the module. + // params defines all the parameters of the module. Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"` // accounts are the accounts present at genesis. Accounts []*types.Any `protobuf:"bytes,2,rep,name=accounts,proto3" json:"accounts,omitempty"` diff --git a/x/auth/types/keys.go b/x/auth/types/keys.go index e3488bbc07a2..0a3582ca294e 100644 --- a/x/auth/types/keys.go +++ b/x/auth/types/keys.go @@ -19,6 +19,9 @@ const ( ) var ( + // ParamsKey is the prefix for params key + ParamsKey = []byte{0x00} + // AddressStoreKeyPrefix prefix for account-by-address store AddressStoreKeyPrefix = []byte{0x01} diff --git a/x/auth/types/msgs.go b/x/auth/types/msgs.go new file mode 100644 index 000000000000..c0f25ee1e023 --- /dev/null +++ b/x/auth/types/msgs.go @@ -0,0 +1,32 @@ +package types + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" +) + +var _ sdk.Msg = &MsgUpdateParams{} + +// GetSignBytes implements the LegacyMsg interface. +func (msg MsgUpdateParams) GetSignBytes() []byte { + return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&msg)) +} + +// GetSigners returns the expected signers for a MsgUpdateParams message. +func (msg *MsgUpdateParams) GetSigners() []sdk.AccAddress { + addr, _ := sdk.AccAddressFromBech32(msg.Authority) + return []sdk.AccAddress{addr} +} + +// ValidateBasic does a sanity check on the provided data. +func (msg *MsgUpdateParams) ValidateBasic() error { + if _, err := sdk.AccAddressFromBech32(msg.Authority); err != nil { + return sdkerrors.Wrap(err, "invalid authority address") + } + + if err := msg.Params.Validate(); err != nil { + return err + } + + return nil +} diff --git a/x/auth/types/params.go b/x/auth/types/params.go index 5374534417ff..a97544e6e6b1 100644 --- a/x/auth/types/params.go +++ b/x/auth/types/params.go @@ -4,8 +4,6 @@ import ( "fmt" "sigs.k8s.io/yaml" - - paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" ) // Default parameter values @@ -17,17 +15,6 @@ const ( DefaultSigVerifyCostSecp256k1 uint64 = 1000 ) -// Parameter keys -var ( - KeyMaxMemoCharacters = []byte("MaxMemoCharacters") - KeyTxSigLimit = []byte("TxSigLimit") - KeyTxSizeCostPerByte = []byte("TxSizeCostPerByte") - KeySigVerifyCostED25519 = []byte("SigVerifyCostED25519") - KeySigVerifyCostSecp256k1 = []byte("SigVerifyCostSecp256k1") -) - -var _ paramtypes.ParamSet = &Params{} - // NewParams creates a new Params object func NewParams( maxMemoCharacters, txSigLimit, txSizeCostPerByte, sigVerifyCostED25519, sigVerifyCostSecp256k1 uint64, @@ -41,23 +28,6 @@ func NewParams( } } -// ParamKeyTable for auth module -func ParamKeyTable() paramtypes.KeyTable { - return paramtypes.NewKeyTable().RegisterParamSet(&Params{}) -} - -// ParamSetPairs implements the ParamSet interface and returns all the key/value pairs -// pairs of auth module's parameters. -func (p *Params) ParamSetPairs() paramtypes.ParamSetPairs { - return paramtypes.ParamSetPairs{ - paramtypes.NewParamSetPair(KeyMaxMemoCharacters, &p.MaxMemoCharacters, validateMaxMemoCharacters), - paramtypes.NewParamSetPair(KeyTxSigLimit, &p.TxSigLimit, validateTxSigLimit), - paramtypes.NewParamSetPair(KeyTxSizeCostPerByte, &p.TxSizeCostPerByte, validateTxSizeCostPerByte), - paramtypes.NewParamSetPair(KeySigVerifyCostED25519, &p.SigVerifyCostED25519, validateSigVerifyCostED25519), - paramtypes.NewParamSetPair(KeySigVerifyCostSecp256k1, &p.SigVerifyCostSecp256k1, validateSigVerifyCostSecp256k1), - } -} - // DefaultParams returns a default set of parameters. func DefaultParams() Params { return Params{ diff --git a/x/auth/types/params_legacy.go b/x/auth/types/params_legacy.go new file mode 100644 index 000000000000..6131c56d11f1 --- /dev/null +++ b/x/auth/types/params_legacy.go @@ -0,0 +1,40 @@ +/* +NOTE: Usage of x/params to manage parameters is deprecated in favor of x/gov +controlled execution of MsgUpdateParams messages. These types remains solely +for migration purposes and will be removed in a future release. +*/ +package types + +import ( + paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" +) + +// Parameter keys +var ( + KeyMaxMemoCharacters = []byte("MaxMemoCharacters") + KeyTxSigLimit = []byte("TxSigLimit") + KeyTxSizeCostPerByte = []byte("TxSizeCostPerByte") + KeySigVerifyCostED25519 = []byte("SigVerifyCostED25519") + KeySigVerifyCostSecp256k1 = []byte("SigVerifyCostSecp256k1") +) + +var _ paramtypes.ParamSet = &Params{} + +// ParamKeyTable for auth module +// +// NOTE: Deprecated. +func ParamKeyTable() paramtypes.KeyTable { + return paramtypes.NewKeyTable().RegisterParamSet(&Params{}) +} + +// ParamSetPairs implements the ParamSet interface and returns all the key/value pairs +// pairs of auth module's parameters. +func (p *Params) ParamSetPairs() paramtypes.ParamSetPairs { + return paramtypes.ParamSetPairs{ + paramtypes.NewParamSetPair(KeyMaxMemoCharacters, &p.MaxMemoCharacters, validateMaxMemoCharacters), + paramtypes.NewParamSetPair(KeyTxSigLimit, &p.TxSigLimit, validateTxSigLimit), + paramtypes.NewParamSetPair(KeyTxSizeCostPerByte, &p.TxSizeCostPerByte, validateTxSizeCostPerByte), + paramtypes.NewParamSetPair(KeySigVerifyCostED25519, &p.SigVerifyCostED25519, validateSigVerifyCostED25519), + paramtypes.NewParamSetPair(KeySigVerifyCostSecp256k1, &p.SigVerifyCostSecp256k1, validateSigVerifyCostSecp256k1), + } +} diff --git a/x/auth/types/tx.pb.go b/x/auth/types/tx.pb.go new file mode 100644 index 000000000000..9b60a3c289bf --- /dev/null +++ b/x/auth/types/tx.pb.go @@ -0,0 +1,603 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: cosmos/auth/v1beta1/tx.proto + +package types + +import ( + context "context" + fmt "fmt" + _ "github.com/cosmos/cosmos-proto" + _ "github.com/cosmos/cosmos-sdk/types/msgservice" + _ "github.com/gogo/protobuf/gogoproto" + grpc1 "github.com/gogo/protobuf/grpc" + proto "github.com/gogo/protobuf/proto" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +// MsgUpdateParams is the Msg/UpdateParams request type. +// +// Since: cosmos-sdk 0.47 +type MsgUpdateParams struct { + // authority is the address of the governance account. + Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"` + // params defines the x/auth parameters to update. + // + // NOTE: All parameters must be supplied. + Params Params `protobuf:"bytes,2,opt,name=params,proto3" json:"params"` +} + +func (m *MsgUpdateParams) Reset() { *m = MsgUpdateParams{} } +func (m *MsgUpdateParams) String() string { return proto.CompactTextString(m) } +func (*MsgUpdateParams) ProtoMessage() {} +func (*MsgUpdateParams) Descriptor() ([]byte, []int) { + return fileDescriptor_c2d62bd9c4c212e5, []int{0} +} +func (m *MsgUpdateParams) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgUpdateParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgUpdateParams.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *MsgUpdateParams) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgUpdateParams.Merge(m, src) +} +func (m *MsgUpdateParams) XXX_Size() int { + return m.Size() +} +func (m *MsgUpdateParams) XXX_DiscardUnknown() { + xxx_messageInfo_MsgUpdateParams.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgUpdateParams proto.InternalMessageInfo + +func (m *MsgUpdateParams) GetAuthority() string { + if m != nil { + return m.Authority + } + return "" +} + +func (m *MsgUpdateParams) GetParams() Params { + if m != nil { + return m.Params + } + return Params{} +} + +// MsgUpdateParamsResponse defines the response structure for executing a +// MsgUpdateParams message. +// +// Since: cosmos-sdk 0.47 +type MsgUpdateParamsResponse struct { +} + +func (m *MsgUpdateParamsResponse) Reset() { *m = MsgUpdateParamsResponse{} } +func (m *MsgUpdateParamsResponse) String() string { return proto.CompactTextString(m) } +func (*MsgUpdateParamsResponse) ProtoMessage() {} +func (*MsgUpdateParamsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_c2d62bd9c4c212e5, []int{1} +} +func (m *MsgUpdateParamsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgUpdateParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgUpdateParamsResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *MsgUpdateParamsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgUpdateParamsResponse.Merge(m, src) +} +func (m *MsgUpdateParamsResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgUpdateParamsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgUpdateParamsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgUpdateParamsResponse proto.InternalMessageInfo + +func init() { + proto.RegisterType((*MsgUpdateParams)(nil), "cosmos.auth.v1beta1.MsgUpdateParams") + proto.RegisterType((*MsgUpdateParamsResponse)(nil), "cosmos.auth.v1beta1.MsgUpdateParamsResponse") +} + +func init() { proto.RegisterFile("cosmos/auth/v1beta1/tx.proto", fileDescriptor_c2d62bd9c4c212e5) } + +var fileDescriptor_c2d62bd9c4c212e5 = []byte{ + // 310 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x49, 0xce, 0x2f, 0xce, + 0xcd, 0x2f, 0xd6, 0x4f, 0x2c, 0x2d, 0xc9, 0xd0, 0x2f, 0x33, 0x4c, 0x4a, 0x2d, 0x49, 0x34, 0xd4, + 0x2f, 0xa9, 0xd0, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x86, 0xc8, 0xea, 0x81, 0x64, 0xf5, + 0xa0, 0xb2, 0x52, 0x22, 0xe9, 0xf9, 0xe9, 0xf9, 0x60, 0x79, 0x7d, 0x10, 0x0b, 0xa2, 0x54, 0x4a, + 0x12, 0xa2, 0x34, 0x1e, 0x22, 0x01, 0xd5, 0x07, 0x91, 0x12, 0x87, 0xda, 0x91, 0x5b, 0x9c, 0xae, + 0x5f, 0x66, 0x08, 0xa2, 0xa0, 0x12, 0x72, 0xd8, 0x2c, 0x07, 0xdb, 0x05, 0x96, 0x57, 0x9a, 0xc2, + 0xc8, 0xc5, 0xef, 0x5b, 0x9c, 0x1e, 0x5a, 0x90, 0x92, 0x58, 0x92, 0x1a, 0x90, 0x58, 0x94, 0x98, + 0x5b, 0x2c, 0x64, 0xc6, 0xc5, 0x09, 0x52, 0x91, 0x5f, 0x94, 0x59, 0x52, 0x29, 0xc1, 0xa8, 0xc0, + 0xa8, 0xc1, 0xe9, 0x24, 0x71, 0x69, 0x8b, 0xae, 0x08, 0xd4, 0x46, 0xc7, 0x94, 0x94, 0xa2, 0xd4, + 0xe2, 0xe2, 0xe0, 0x92, 0xa2, 0xcc, 0xbc, 0xf4, 0x20, 0x84, 0x52, 0x21, 0x4b, 0x2e, 0xb6, 0x02, + 0xb0, 0x09, 0x12, 0x4c, 0x0a, 0x8c, 0x1a, 0xdc, 0x46, 0xd2, 0x7a, 0x58, 0xfc, 0xa6, 0x07, 0xb1, + 0xc4, 0x89, 0xe5, 0xc4, 0x3d, 0x79, 0x86, 0x20, 0xa8, 0x06, 0x2b, 0xbe, 0xa6, 0xe7, 0x1b, 0xb4, + 0x10, 0x46, 0x29, 0x49, 0x72, 0x89, 0xa3, 0xb9, 0x2a, 0x28, 0xb5, 0xb8, 0x20, 0x3f, 0xaf, 0x38, + 0xd5, 0x28, 0x93, 0x8b, 0xd9, 0xb7, 0x38, 0x5d, 0x28, 0x89, 0x8b, 0x07, 0xc5, 0xd1, 0x2a, 0x58, + 0x2d, 0x43, 0x33, 0x44, 0x4a, 0x87, 0x18, 0x55, 0x30, 0xab, 0x9c, 0x9c, 0x4f, 0x3c, 0x92, 0x63, + 0xbc, 0xf0, 0x48, 0x8e, 0xf1, 0xc1, 0x23, 0x39, 0xc6, 0x09, 0x8f, 0xe5, 0x18, 0x2e, 0x3c, 0x96, + 0x63, 0xb8, 0xf1, 0x58, 0x8e, 0x21, 0x4a, 0x33, 0x3d, 0xb3, 0x24, 0xa3, 0x34, 0x49, 0x2f, 0x39, + 0x3f, 0x17, 0x1a, 0x11, 0x50, 0x4a, 0xb7, 0x38, 0x25, 0x5b, 0xbf, 0x02, 0x12, 0xdc, 0x25, 0x95, + 0x05, 0xa9, 0xc5, 0x49, 0x6c, 0xe0, 0x80, 0x36, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x46, 0x68, + 0x6d, 0x75, 0x07, 0x02, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// MsgClient is the client API for Msg service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type MsgClient interface { + // UpdateParams defines a governance operation for updating the x/auth module + // parameters. The authority is hard-coded to the x/gov module account. + // + // Since: cosmos-sdk 0.47 + UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) +} + +type msgClient struct { + cc grpc1.ClientConn +} + +func NewMsgClient(cc grpc1.ClientConn) MsgClient { + return &msgClient{cc} +} + +func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) { + out := new(MsgUpdateParamsResponse) + err := c.cc.Invoke(ctx, "/cosmos.auth.v1beta1.Msg/UpdateParams", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// MsgServer is the server API for Msg service. +type MsgServer interface { + // UpdateParams defines a governance operation for updating the x/auth module + // parameters. The authority is hard-coded to the x/gov module account. + // + // Since: cosmos-sdk 0.47 + UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error) +} + +// UnimplementedMsgServer can be embedded to have forward compatible implementations. +type UnimplementedMsgServer struct { +} + +func (*UnimplementedMsgServer) UpdateParams(ctx context.Context, req *MsgUpdateParams) (*MsgUpdateParamsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateParams not implemented") +} + +func RegisterMsgServer(s grpc1.Server, srv MsgServer) { + s.RegisterService(&_Msg_serviceDesc, srv) +} + +func _Msg_UpdateParams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgUpdateParams) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).UpdateParams(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmos.auth.v1beta1.Msg/UpdateParams", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).UpdateParams(ctx, req.(*MsgUpdateParams)) + } + return interceptor(ctx, in, info, handler) +} + +var _Msg_serviceDesc = grpc.ServiceDesc{ + ServiceName: "cosmos.auth.v1beta1.Msg", + HandlerType: (*MsgServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "UpdateParams", + Handler: _Msg_UpdateParams_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "cosmos/auth/v1beta1/tx.proto", +} + +func (m *MsgUpdateParams) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgUpdateParams) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgUpdateParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Params.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + if len(m.Authority) > 0 { + i -= len(m.Authority) + copy(dAtA[i:], m.Authority) + i = encodeVarintTx(dAtA, i, uint64(len(m.Authority))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgUpdateParamsResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgUpdateParamsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgUpdateParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func encodeVarintTx(dAtA []byte, offset int, v uint64) int { + offset -= sovTx(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *MsgUpdateParams) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Authority) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = m.Params.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgUpdateParamsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func sovTx(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozTx(x uint64) (n int) { + return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *MsgUpdateParams) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgUpdateParams: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgUpdateParams: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Authority = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgUpdateParamsResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgUpdateParamsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgUpdateParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipTx(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthTx + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupTx + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthTx + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthTx = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowTx = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupTx = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/bank/keeper/keeper_test.go b/x/bank/keeper/keeper_test.go index 0c6caee7016a..1c4390abbcbd 100644 --- a/x/bank/keeper/keeper_test.go +++ b/x/bank/keeper/keeper_test.go @@ -24,6 +24,7 @@ import ( "github.com/cosmos/cosmos-sdk/x/bank/keeper" "github.com/cosmos/cosmos-sdk/x/bank/testutil" "github.com/cosmos/cosmos-sdk/x/bank/types" + govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" minttypes "github.com/cosmos/cosmos-sdk/x/mint/types" ) @@ -86,8 +87,8 @@ func (suite *IntegrationTestSuite) initKeepersWithmAccPerms(blockedAddrs map[str maccPerms[multiPerm] = []string{authtypes.Burner, authtypes.Minter, authtypes.Staking} maccPerms[randomPerm] = []string{"random"} authKeeper := authkeeper.NewAccountKeeper( - appCodec, app.GetKey(types.StoreKey), app.GetSubspace(types.ModuleName), - authtypes.ProtoBaseAccount, maccPerms, sdk.Bech32MainPrefix, + appCodec, app.GetKey(types.StoreKey), authtypes.ProtoBaseAccount, + maccPerms, sdk.Bech32MainPrefix, authtypes.NewModuleAddress(govtypes.ModuleName).String(), ) keeper := keeper.NewBaseKeeper( appCodec, app.GetKey(types.StoreKey), authKeeper, @@ -279,7 +280,7 @@ func (suite *IntegrationTestSuite) TestSupply_BurnCoins() { Require(). NoError(keeper.MintCoins(ctx, authtypes.Minter, initCoins)) supplyAfterInflation, _, err := keeper.GetPaginatedTotalSupply(ctx, &query.PageRequest{}) - + suite.Require().NoError(err) suite.Require().Panics(func() { keeper.BurnCoins(ctx, "", initCoins) }, "no module account") // nolint:errcheck suite.Require().Panics(func() { keeper.BurnCoins(ctx, authtypes.Minter, initCoins) }, "invalid permission") // nolint:errcheck suite.Require().Panics(func() { keeper.BurnCoins(ctx, randomPerm, supplyAfterInflation) }, "random permission") // nolint:errcheck @@ -304,8 +305,8 @@ func (suite *IntegrationTestSuite) TestSupply_BurnCoins() { authKeeper.SetModuleAccount(ctx, multiPermAcc) err = keeper.BurnCoins(ctx, multiPermAcc.GetName(), initCoins) - supplyAfterBurn, _, err = keeper.GetPaginatedTotalSupply(ctx, &query.PageRequest{}) suite.Require().NoError(err) + supplyAfterBurn, _, err = keeper.GetPaginatedTotalSupply(ctx, &query.PageRequest{}) suite.Require().NoError(err) suite.Require().Equal(sdk.NewCoins().String(), getCoinsByName(ctx, keeper, authKeeper, multiPermAcc.GetName()).String()) suite.Require().Equal(supplyAfterInflation.Sub(initCoins...), supplyAfterBurn) @@ -1053,8 +1054,9 @@ func (suite *IntegrationTestSuite) TestBalanceTrackingEvents() { maccPerms[multiPerm] = []string{authtypes.Burner, authtypes.Minter, authtypes.Staking} suite.app.AccountKeeper = authkeeper.NewAccountKeeper( - suite.app.AppCodec(), suite.app.GetKey(authtypes.StoreKey), suite.app.GetSubspace(authtypes.ModuleName), + suite.app.AppCodec(), suite.app.GetKey(authtypes.StoreKey), authtypes.ProtoBaseAccount, maccPerms, sdk.Bech32MainPrefix, + authtypes.NewModuleAddress(govtypes.ModuleName).String(), ) suite.app.BankKeeper = keeper.NewBaseKeeper(suite.app.AppCodec(), suite.app.GetKey(types.StoreKey), @@ -1180,8 +1182,9 @@ func (suite *IntegrationTestSuite) TestMintCoinRestrictions() { maccPerms[multiPerm] = []string{authtypes.Burner, authtypes.Minter, authtypes.Staking} suite.app.AccountKeeper = authkeeper.NewAccountKeeper( - suite.app.AppCodec(), suite.app.GetKey(authtypes.StoreKey), suite.app.GetSubspace(authtypes.ModuleName), + suite.app.AppCodec(), suite.app.GetKey(authtypes.StoreKey), authtypes.ProtoBaseAccount, maccPerms, sdk.Bech32MainPrefix, + authtypes.NewModuleAddress(govtypes.ModuleName).String(), ) suite.app.AccountKeeper.SetModuleAccount(suite.ctx, multiPermAcc) From 481309872455187e1d49666d974843dbdcfbc343 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 11 Jul 2022 19:27:33 +0200 Subject: [PATCH 22/37] build(deps): Bump github.com/stretchr/testify in /math (#12514) Bumps [github.com/stretchr/testify](https://github.com/stretchr/testify) from 1.7.0 to 1.8.0. - [Release notes](https://github.com/stretchr/testify/releases) - [Commits](https://github.com/stretchr/testify/compare/v1.7.0...v1.8.0) --- updated-dependencies: - dependency-name: github.com/stretchr/testify dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> Co-authored-by: Julien Robert --- math/go.mod | 6 +++--- math/go.sum | 12 ++++++++---- 2 files changed, 11 insertions(+), 7 deletions(-) diff --git a/math/go.mod b/math/go.mod index ac1dfad9d0b3..0fc26ea1a96b 100644 --- a/math/go.mod +++ b/math/go.mod @@ -2,10 +2,10 @@ module cosmossdk.io/math go 1.18 -require github.com/stretchr/testify v1.7.0 +require github.com/stretchr/testify v1.8.0 require ( - github.com/davecgh/go-spew v1.1.0 // indirect + github.com/davecgh/go-spew v1.1.1 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect - gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/math/go.sum b/math/go.sum index acb88a48f684..51648299d59e 100644 --- a/math/go.sum +++ b/math/go.sum @@ -1,11 +1,15 @@ -github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY= -github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= From 81a7f53383110453141bdb9594d74b2e06c6614a Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 11 Jul 2022 19:58:24 +0200 Subject: [PATCH 23/37] build(deps): Bump github.com/stretchr/testify in /depinject (#12519) --- depinject/go.mod | 2 +- depinject/go.sum | 4 +++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/depinject/go.mod b/depinject/go.mod index cb648c954858..4968d4232c51 100644 --- a/depinject/go.mod +++ b/depinject/go.mod @@ -5,7 +5,7 @@ go 1.18 require ( github.com/pkg/errors v0.9.1 github.com/regen-network/gocuke v0.6.2 - github.com/stretchr/testify v1.7.1 + github.com/stretchr/testify v1.8.0 golang.org/x/exp v0.0.0-20220428152302-39d4317da171 gotest.tools/v3 v3.2.0 ) diff --git a/depinject/go.sum b/depinject/go.sum index 57c347b5a126..af358c4e82b1 100644 --- a/depinject/go.sum +++ b/depinject/go.sum @@ -26,10 +26,12 @@ github.com/regen-network/gocuke v0.6.2 h1:pHviZ0kKAq2U2hN2q3smKNxct6hS0mGByFMHGn github.com/regen-network/gocuke v0.6.2/go.mod h1:zYaqIHZobHyd0xOrHGPQjbhGJsuZ1oElx150u2o1xuk= github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.7.1 h1:5TQK59W5E3v0r2duFAb7P95B6hEeOyEnHRa8MjYSMTY= github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= From 316356d05dc9a84fdad3bbd84fa93e2b001591d3 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 11 Jul 2022 20:24:59 +0200 Subject: [PATCH 24/37] build(deps): Bump gotest.tools/v3 from 3.2.0 to 3.3.0 in /depinject (#12517) Bumps [gotest.tools/v3](https://github.com/gotestyourself/gotest.tools) from 3.2.0 to 3.3.0. - [Release notes](https://github.com/gotestyourself/gotest.tools/releases) - [Commits](https://github.com/gotestyourself/gotest.tools/compare/v3.2.0...v3.3.0) --- updated-dependencies: - dependency-name: gotest.tools/v3 dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- depinject/go.mod | 2 +- depinject/go.sum | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/depinject/go.mod b/depinject/go.mod index 4968d4232c51..b5333c5a5c07 100644 --- a/depinject/go.mod +++ b/depinject/go.mod @@ -7,7 +7,7 @@ require ( github.com/regen-network/gocuke v0.6.2 github.com/stretchr/testify v1.8.0 golang.org/x/exp v0.0.0-20220428152302-39d4317da171 - gotest.tools/v3 v3.2.0 + gotest.tools/v3 v3.3.0 ) require ( diff --git a/depinject/go.sum b/depinject/go.sum index af358c4e82b1..12f3a6d451c1 100644 --- a/depinject/go.sum +++ b/depinject/go.sum @@ -64,7 +64,7 @@ gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gotest.tools/v3 v3.2.0 h1:I0DwBVMGAx26dttAj1BtJLAkVGncrkkUXfJLC4Flt/I= -gotest.tools/v3 v3.2.0/go.mod h1:Mcr9QNxkg0uMvy/YElmo4SpXgJKWgQvYrT7Kw5RzJ1A= +gotest.tools/v3 v3.3.0 h1:MfDY1b1/0xN1CyMlQDac0ziEy9zJQd9CXBRRDHw2jJo= +gotest.tools/v3 v3.3.0/go.mod h1:Mcr9QNxkg0uMvy/YElmo4SpXgJKWgQvYrT7Kw5RzJ1A= pgregory.net/rapid v0.4.7 h1:MTNRktPuv5FNqOO151TM9mDTa+XHcX6ypYeISDVD14g= pgregory.net/rapid v0.4.7/go.mod h1:UYpPVyjFHzYBGHIxLFoupi8vwk6rXNzRY9OMvVxFIOU= From 09410c19ea3daf71b497e474fe3ac8011a32906a Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 11 Jul 2022 21:06:32 +0200 Subject: [PATCH 25/37] build(deps): Bump github.com/stretchr/testify in /errors (#12521) Bumps [github.com/stretchr/testify](https://github.com/stretchr/testify) from 1.7.0 to 1.8.0. - [Release notes](https://github.com/stretchr/testify/releases) - [Commits](https://github.com/stretchr/testify/compare/v1.7.0...v1.8.0) --- updated-dependencies: - dependency-name: github.com/stretchr/testify dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> Co-authored-by: Julien Robert --- errors/go.mod | 6 +++--- errors/go.sum | 11 ++++++++--- 2 files changed, 11 insertions(+), 6 deletions(-) diff --git a/errors/go.mod b/errors/go.mod index c798fa867709..454a925700cd 100644 --- a/errors/go.mod +++ b/errors/go.mod @@ -4,15 +4,15 @@ go 1.18 require ( github.com/pkg/errors v0.9.1 - github.com/stretchr/testify v1.7.0 + github.com/stretchr/testify v1.8.0 google.golang.org/grpc v1.45.0 ) require ( - github.com/davecgh/go-spew v1.1.0 // indirect + github.com/davecgh/go-spew v1.1.1 // indirect github.com/golang/protobuf v1.5.2 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013 // indirect google.golang.org/protobuf v1.26.0 // indirect - gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/errors/go.sum b/errors/go.sum index cff25191d667..5bc9d35681c2 100644 --- a/errors/go.sum +++ b/errors/go.sum @@ -11,8 +11,9 @@ github.com/cncf/udpa/go v0.0.0-20210930031921-04548b0d99d4/go.mod h1:6pvJx4me5XP github.com/cncf/xds/go v0.0.0-20210805033703-aa0b78936158/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= github.com/cncf/xds/go v0.0.0-20210922020428-25de7278fc84/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= -github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98= @@ -52,9 +53,12 @@ github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZN github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= -github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= @@ -121,7 +125,8 @@ gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+ gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= -gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= From 6d2c03e9decc31ced91ccdd0ff1e629ad5c90f3e Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 11 Jul 2022 21:29:06 +0200 Subject: [PATCH 26/37] build(deps): Bump google.golang.org/grpc in /client/v2 (#12515) Bumps [google.golang.org/grpc](https://github.com/grpc/grpc-go) from 1.45.0 to 1.47.0. - [Release notes](https://github.com/grpc/grpc-go/releases) - [Commits](https://github.com/grpc/grpc-go/compare/v1.45.0...v1.47.0) --- updated-dependencies: - dependency-name: google.golang.org/grpc dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- client/v2/go.mod | 2 +- client/v2/go.sum | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/client/v2/go.mod b/client/v2/go.mod index d83f8b8ab04b..8f239c2ec905 100644 --- a/client/v2/go.mod +++ b/client/v2/go.mod @@ -8,7 +8,7 @@ require ( github.com/iancoleman/strcase v0.2.0 github.com/spf13/cobra v1.4.0 github.com/spf13/pflag v1.0.5 - google.golang.org/grpc v1.45.0 + google.golang.org/grpc v1.47.0 google.golang.org/protobuf v1.28.0 gotest.tools/v3 v3.1.0 ) diff --git a/client/v2/go.sum b/client/v2/go.sum index 8ff37c70268b..99c1a28e9bae 100644 --- a/client/v2/go.sum +++ b/client/v2/go.sum @@ -11,8 +11,8 @@ github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGX github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= github.com/cncf/udpa/go v0.0.0-20210930031921-04548b0d99d4/go.mod h1:6pvJx4me5XPnfI9Z40ddWsdw2W/uZgQLFXToKeRcDiI= github.com/cncf/xds/go v0.0.0-20210312221358-fbca930ec8ed/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= -github.com/cncf/xds/go v0.0.0-20210805033703-aa0b78936158/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= github.com/cncf/xds/go v0.0.0-20210922020428-25de7278fc84/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20211001041855-01bcc9b48dfe/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= github.com/cosmos/cosmos-proto v1.0.0-alpha7 h1:yqYUOHF2jopwZh4dVQp3xgqwftE5/2hkrwIV6vkUbO0= github.com/cosmos/cosmos-proto v1.0.0-alpha7/go.mod h1:dosO4pSAbJF8zWCzCoTWP7nNsjcvSUBQmniFxDg5daw= @@ -25,7 +25,7 @@ github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.m github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98= github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk= github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.mod h1:hliV/p42l8fGbc6Y9bQ70uLwIvmJyVE5k4iMKlh8wCQ= -github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021/go.mod h1:AFq3mo9L8Lqqiid3OhADV3RfLJnjiw63cSpi+fDTRC0= +github.com/envoyproxy/go-control-plane v0.10.2-0.20220325020618-49ff273808a1/go.mod h1:KJwIaB5Mv44NWtYuAOFCVOjcI94vtpEz2JU/D2v6IjE= github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= @@ -153,8 +153,8 @@ google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8 google.golang.org/grpc v1.33.1/go.mod h1:fr5YgcSWrqhRRxogOsw7RzIpsmvOZ6IcH4kBYTpR3n0= google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= google.golang.org/grpc v1.40.0/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34= -google.golang.org/grpc v1.45.0 h1:NEpgUqV3Z+ZjkqMsxMg11IaDrXY4RY6CQukSGK0uI1M= -google.golang.org/grpc v1.45.0/go.mod h1:lN7owxKUQEqMfSyQikvvk5tf/6zMPsrK+ONuO11+0rQ= +google.golang.org/grpc v1.47.0 h1:9n77onPX5F3qfFCqjy9dhn8PbNQsIKeVU04J9G7umt8= +google.golang.org/grpc v1.47.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= From 99f28d6069513a73749e1ac409cdf88ce3b3c0ed Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 11 Jul 2022 21:48:52 +0200 Subject: [PATCH 27/37] build(deps): Bump gotest.tools/v3 from 3.2.0 to 3.3.0 in /core (#12522) --- core/go.mod | 4 ++-- core/go.sum | 6 +++--- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/core/go.mod b/core/go.mod index a5e7a119f796..ce462a60efde 100644 --- a/core/go.mod +++ b/core/go.mod @@ -4,10 +4,10 @@ go 1.18 require ( cosmossdk.io/api v0.1.0-alpha8 - github.com/cosmos/cosmos-proto v1.0.0-alpha7 cosmossdk.io/depinject v1.0.0-alpha.4 + github.com/cosmos/cosmos-proto v1.0.0-alpha7 google.golang.org/protobuf v1.28.0 - gotest.tools/v3 v3.2.0 + gotest.tools/v3 v3.3.0 sigs.k8s.io/yaml v1.3.0 ) diff --git a/core/go.sum b/core/go.sum index 9f34a20f624e..3ba6843578a2 100644 --- a/core/go.sum +++ b/core/go.sum @@ -75,7 +75,7 @@ github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnIn github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.7.1 h1:5TQK59W5E3v0r2duFAb7P95B6hEeOyEnHRa8MjYSMTY= +github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk= github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= @@ -174,8 +174,8 @@ gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -gotest.tools/v3 v3.2.0 h1:I0DwBVMGAx26dttAj1BtJLAkVGncrkkUXfJLC4Flt/I= -gotest.tools/v3 v3.2.0/go.mod h1:Mcr9QNxkg0uMvy/YElmo4SpXgJKWgQvYrT7Kw5RzJ1A= +gotest.tools/v3 v3.3.0 h1:MfDY1b1/0xN1CyMlQDac0ziEy9zJQd9CXBRRDHw2jJo= +gotest.tools/v3 v3.3.0/go.mod h1:Mcr9QNxkg0uMvy/YElmo4SpXgJKWgQvYrT7Kw5RzJ1A= honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= pgregory.net/rapid v0.4.7 h1:MTNRktPuv5FNqOO151TM9mDTa+XHcX6ypYeISDVD14g= From fadbf6be71b60e9bac89483c925418620c0c58db Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 11 Jul 2022 22:13:00 +0200 Subject: [PATCH 28/37] build(deps): Bump github.com/cosmos/cosmos-sdk in /store/tools/ics23 (#12525) Bumps [github.com/cosmos/cosmos-sdk](https://github.com/cosmos/cosmos-sdk) from 0.45.0 to 0.45.6. - [Release notes](https://github.com/cosmos/cosmos-sdk/releases) - [Changelog](https://github.com/cosmos/cosmos-sdk/blob/main/CHANGELOG.md) - [Commits](https://github.com/cosmos/cosmos-sdk/compare/v0.45.0...v0.45.6) --- updated-dependencies: - dependency-name: github.com/cosmos/cosmos-sdk dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- store/tools/ics23/go.mod | 18 +- store/tools/ics23/go.sum | 464 +++++++++++++++++++++++---------------- 2 files changed, 278 insertions(+), 204 deletions(-) diff --git a/store/tools/ics23/go.mod b/store/tools/ics23/go.mod index 2918a1834713..7fbccba6c809 100644 --- a/store/tools/ics23/go.mod +++ b/store/tools/ics23/go.mod @@ -4,10 +4,10 @@ go 1.18 require ( github.com/confio/ics23/go v0.6.7-0.20220201201850-606d5105384e - github.com/cosmos/cosmos-sdk v0.45.0 + github.com/cosmos/cosmos-sdk v0.45.6 github.com/cosmos/iavl v0.17.3 github.com/lazyledger/smt v0.2.1-0.20210709230900-03ea40719554 - github.com/tendermint/tendermint v0.34.14 + github.com/tendermint/tendermint v0.34.19 github.com/tendermint/tm-db v0.6.7 ) @@ -21,7 +21,7 @@ require ( github.com/dustin/go-humanize v1.0.0 // indirect github.com/gogo/protobuf v1.3.3 // indirect github.com/golang/protobuf v1.5.2 // indirect - github.com/golang/snappy v0.0.3-0.20201103224600-674baa8c7fc3 // indirect + github.com/golang/snappy v0.0.3 // indirect github.com/google/btree v1.0.0 // indirect github.com/grpc-ecosystem/grpc-gateway v1.16.0 // indirect github.com/jmhodges/levigo v1.0.0 // indirect @@ -30,12 +30,12 @@ require ( github.com/sasha-s/go-deadlock v0.2.1-0.20190427202633-1595213edefa // indirect github.com/syndtr/goleveldb v1.0.1-0.20200815110645-5c35d600f0ca // indirect go.etcd.io/bbolt v1.3.6 // indirect - golang.org/x/crypto v0.0.0-20210817164053-32db794688a5 // indirect - golang.org/x/net v0.0.0-20210903162142-ad29c8ab022f // indirect - golang.org/x/sys v0.0.0-20210903071746-97244b99971b // indirect - golang.org/x/text v0.3.6 // indirect - google.golang.org/genproto v0.0.0-20210828152312-66f60bf46e71 // indirect - google.golang.org/grpc v1.44.0 // indirect + golang.org/x/crypto v0.0.0-20210915214749-c084706c2272 // indirect + golang.org/x/net v0.0.0-20211208012354-db4efeb81f4b // indirect + golang.org/x/sys v0.0.0-20220114195835-da31bd327af9 // indirect + golang.org/x/text v0.3.7 // indirect + google.golang.org/genproto v0.0.0-20211223182754-3ac035c7e7cb // indirect + google.golang.org/grpc v1.45.0 // indirect google.golang.org/protobuf v1.27.1 // indirect ) diff --git a/store/tools/ics23/go.sum b/store/tools/ics23/go.sum index ec95070e3fcd..693821e0f0d9 100644 --- a/store/tools/ics23/go.sum +++ b/store/tools/ics23/go.sum @@ -1,3 +1,4 @@ +bazil.org/fuse v0.0.0-20200407214033-5883e5a4b512/go.mod h1:FbcW6z/2VytnFDhZfumh8Ss8zxHE6qpMP5sHTRe0EaM= cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU= @@ -18,6 +19,14 @@ cloud.google.com/go v0.74.0/go.mod h1:VV1xSbzvo+9QJOxLDaJfTjx5e+MePCpCWwvftOeQmW cloud.google.com/go v0.78.0/go.mod h1:QjdrLG0uq+YwhjoVOLsS1t7TW8fs36kLs4XO5R5ECHg= cloud.google.com/go v0.79.0/go.mod h1:3bzgcEeQlzbuEAYu4mrWhKqWjmpprinYgKJLgKHnbb8= cloud.google.com/go v0.81.0/go.mod h1:mk/AM35KwGk/Nm2YSeZbxXdrNK3KZOYHmLkOqC2V6E0= +cloud.google.com/go v0.83.0/go.mod h1:Z7MJUsANfY0pYPdw0lbnivPx4/vhy/e2FEkSkF7vAVY= +cloud.google.com/go v0.84.0/go.mod h1:RazrYuxIK6Kb7YrzzhPoLmCVzl7Sup4NrbKPg8KHSUM= +cloud.google.com/go v0.87.0/go.mod h1:TpDYlFy7vuLzZMMZ+B6iRiELaY7z/gJPaqbMx6mlWcY= +cloud.google.com/go v0.90.0/go.mod h1:kRX0mNRHe0e2rC6oNakvwQqzyDmg57xJ+SZU1eT2aDQ= +cloud.google.com/go v0.93.3/go.mod h1:8utlLll2EF5XMAV15woO4lSbWQlk8rer9aLOfLh7+YI= +cloud.google.com/go v0.94.1/go.mod h1:qAlAugsXlC+JWO+Bke5vCtc9ONxjQT3drlTTnAplMW4= +cloud.google.com/go v0.97.0/go.mod h1:GF7l59pYBVlXQIBLx3a761cZ41F9bBH3JUlihCt2Udc= +cloud.google.com/go v0.99.0/go.mod h1:w0Xx2nLzqWJPuozYQX+hFfCSI8WioryfRDzkoI/Y2ZA= cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o= cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE= cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc= @@ -27,6 +36,7 @@ cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM7 cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE= cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk= cloud.google.com/go/firestore v1.1.0/go.mod h1:ulACoGHTpvq5r8rxGJ4ddJZBZqakUQqClKRT5SZwBmk= +cloud.google.com/go/firestore v1.6.1/go.mod h1:asNXNOzBdyVQmEU+ggO8UPodTkEVFW5Qx+rwHnAz+EY= cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I= cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw= cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA= @@ -37,82 +47,73 @@ cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohl cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs= cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0= dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU= -filippo.io/edwards25519 v1.0.0-beta.2/go.mod h1:X+pm78QAUPtFLi1z9PYIlS/bdDnvbCOGKtZ+ACWEf7o= -github.com/99designs/keyring v1.1.6/go.mod h1:16e0ds7LGQQcT59QqkTg72Hh5ShM51Byv5PEmW6uoRU= -github.com/Azure/azure-pipeline-go v0.2.1/go.mod h1:UGSo8XybXnIGZ3epmeBw7Jdz+HiUVpqIlpz/HKHylF4= -github.com/Azure/azure-pipeline-go v0.2.2/go.mod h1:4rQ/NZncSvGqNkkOsNpOU1tgoNuIlp9AfUH5G1tvCHc= -github.com/Azure/azure-storage-blob-go v0.7.0/go.mod h1:f9YQKtsG1nMisotuTPpO0tjNuEjKRYAcJU8/ydDI++4= +github.com/Azure/azure-sdk-for-go/sdk/azcore v0.19.0/go.mod h1:h6H6c8enJmmocHUbLiiGY6sx7f9i+X3m1CHdd5c6Rdw= +github.com/Azure/azure-sdk-for-go/sdk/azidentity v0.11.0/go.mod h1:HcM1YX14R7CJcghJGOYCgdezslRSVzqwLf/q+4Y2r/0= +github.com/Azure/azure-sdk-for-go/sdk/internal v0.7.0/go.mod h1:yqy467j36fJxcRV2TzfVZ1pCb5vxm4BtZPUdYWe/Xo8= github.com/Azure/go-ansiterm v0.0.0-20170929234023-d6e3b3328b78/go.mod h1:LmzpDX56iTiv29bbRTIsUNlaFfuhWRQBWjQdVyAevI8= github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E= -github.com/Azure/go-autorest/autorest v0.9.0/go.mod h1:xyHB1BMZT0cuDHU7I0+g046+BFDTQ8rEZB0s4Yfa6bI= -github.com/Azure/go-autorest/autorest/adal v0.5.0/go.mod h1:8Z9fGy2MpX0PvDjB1pEgQTmVqjGhiHBW7RJJEciWzS0= -github.com/Azure/go-autorest/autorest/adal v0.8.0/go.mod h1:Z6vX6WXXuyieHAXwMj0S6HY6e6wcHn37qQMBQlvY3lc= -github.com/Azure/go-autorest/autorest/date v0.1.0/go.mod h1:plvfp3oPSKwf2DNjlBjWF/7vwR+cUD/ELuzDCXwHUVA= -github.com/Azure/go-autorest/autorest/date v0.2.0/go.mod h1:vcORJHLJEh643/Ioh9+vPmf1Ij9AEBM5FuBIXLmIy0g= -github.com/Azure/go-autorest/autorest/mocks v0.1.0/go.mod h1:OTyCOPRA2IgIlWxVYxBee2F5Gr4kF2zd2J5cFRaIDN0= -github.com/Azure/go-autorest/autorest/mocks v0.2.0/go.mod h1:OTyCOPRA2IgIlWxVYxBee2F5Gr4kF2zd2J5cFRaIDN0= -github.com/Azure/go-autorest/autorest/mocks v0.3.0/go.mod h1:a8FDP3DYzQ4RYfVAxAN3SVSiiO77gL2j2ronKKP0syM= -github.com/Azure/go-autorest/logger v0.1.0/go.mod h1:oExouG+K6PryycPJfVSxi/koC6LSNgds39diKLz7Vrc= -github.com/Azure/go-autorest/tracing v0.5.0/go.mod h1:r/s2XiOKccPW3HrqB+W0TQzfbtp2fGCgRFtBroKn4Dk= github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= +github.com/BurntSushi/toml v1.1.0/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ= github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo= github.com/ChainSafe/go-schnorrkel v0.0.0-20200405005733-88cbf1b4c40d/go.mod h1:URdX5+vg25ts3aCh8H5IFZybJYKWhJHYMTnf+ULtoC4= +github.com/DATA-DOG/go-sqlmock v1.5.0/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM= github.com/DataDog/datadog-go v3.2.0+incompatible/go.mod h1:LButxg5PwREeZtORoXG3tL4fMGNddJ+vMq1mwgfaqoQ= github.com/DataDog/zstd v1.4.1/go.mod h1:1jcaCB/ufaK+sKp1NBhlGmpz41jOoPQ35bpF36t7BBo= github.com/DataDog/zstd v1.4.5 h1:EndNeuB0l9syBZhut0wns3gV1hL8zX8LIu6ZiVHWLIQ= github.com/DataDog/zstd v1.4.5/go.mod h1:1jcaCB/ufaK+sKp1NBhlGmpz41jOoPQ35bpF36t7BBo= +github.com/HdrHistogram/hdrhistogram-go v1.1.0/go.mod h1:yDgFjdqOqDEKOvasDdhWNXYg9BVp4O+o5f6V/ehm6Oo= +github.com/HdrHistogram/hdrhistogram-go v1.1.2/go.mod h1:yDgFjdqOqDEKOvasDdhWNXYg9BVp4O+o5f6V/ehm6Oo= github.com/Knetic/govaluate v3.0.1-0.20171022003610-9aa49832a739+incompatible/go.mod h1:r7JcOSlj0wfOMncg0iLm8Leh48TZaKVeNIfJntJ2wa0= github.com/Microsoft/go-winio v0.4.14/go.mod h1:qXqCSQ3Xa7+6tgxaGTIe4Kpcdsi+P8jBhyzoq1bpyYA= github.com/Microsoft/go-winio v0.5.0/go.mod h1:JPGBdM1cNvN/6ISo+n8V5iA4v8pBzdOpzfwIujj1a84= +github.com/Microsoft/go-winio v0.5.1/go.mod h1:JPGBdM1cNvN/6ISo+n8V5iA4v8pBzdOpzfwIujj1a84= github.com/Nvveen/Gotty v0.0.0-20120604004816-cd527374f1e5/go.mod h1:lmUJ/7eu/Q8D7ML55dXQrVaamCz2vxCfdQBasLZfHKk= github.com/OneOfOne/xxhash v1.2.2 h1:KMrpdQIwFcEqXDklaen+P1axHaj9BSKzvpUUfnHldSE= github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU= github.com/Shopify/sarama v1.19.0/go.mod h1:FVkBWblsNy7DGZRfXLU0O9RCGt5g3g3yEuWXgklEdEo= github.com/Shopify/toxiproxy v2.1.4+incompatible/go.mod h1:OXgGpZ6Cli1/URJOF1DMxUHB2q5Ap20/P/eIdh4G0pI= -github.com/StackExchange/wmi v0.0.0-20180116203802-5d049714c4a6/go.mod h1:3eOhrUMpNV+6aFIbp5/iudMxNCF27Vw2OZgy4xEx0Fg= -github.com/VictoriaMetrics/fastcache v1.5.7/go.mod h1:ptDBkNMQI4RtmVo8VS/XwRY6RoTu1dAWCbrk+6WsEM8= github.com/VividCortex/gohistogram v1.0.0/go.mod h1:Pf5mBqqDxYaXu3hDrrU+w6nw50o/4+TcAqDqk/vUH7g= github.com/Workiva/go-datastructures v1.0.52/go.mod h1:Z+F2Rca0qCsVYDS8z7bAGm8f3UkzuWYS/oBZz5a7VVA= -github.com/Zilliqa/gozilliqa-sdk v1.2.1-0.20201201074141-dd0ecada1be6/go.mod h1:eSYp2T6f0apnuW8TzhV3f6Aff2SE8Dwio++U4ha4yEM= +github.com/Workiva/go-datastructures v1.0.53/go.mod h1:1yZL+zfsztete+ePzZz/Zb1/t5BnDuE2Ya2MMGhzP6A= github.com/adlio/schema v1.1.13/go.mod h1:L5Z7tw+7lRK1Fnpi/LT/ooCP1elkXn0krMWBQHUhEDE= +github.com/adlio/schema v1.3.0/go.mod h1:51QzxkpeFs6lRY11kPye26IaFPOV+HqEj01t5aXXKfs= github.com/aead/siphash v1.0.1/go.mod h1:Nywa3cDsYNNK3gaciGTWPwHt0wlpNV15vwmswBAUSII= github.com/afex/hystrix-go v0.0.0-20180502004556-fa1af6a1f4f5/go.mod h1:SkGFH1ia65gfNATL8TAiHDNxPzPdmEL5uirI2Uyuz6c= +github.com/ajstarks/svgo v0.0.0-20180226025133-644b8db467af/go.mod h1:K08gAheRH3/J6wwsYMMT4xOr94bZjxIelGM0+d/wbFw= github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc= github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc= github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0= github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0= github.com/alecthomas/units v0.0.0-20190924025748-f65c72e2690d/go.mod h1:rBZYJk541a8SKzHPHnH3zbiI+7dagKZ0cgpgrD7Fyho= -github.com/allegro/bigcache v1.2.1-0.20190218064605-e24eb225f156/go.mod h1:Cb/ax3seSYIx7SuZdm2G2xzfwmv3TPSk2ucNfQESPXM= github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY= github.com/apache/thrift v0.12.0/go.mod h1:cp2SuWMxlEZw2r+iP2GNCdIi4C1qmUzdZFSVb+bacwQ= github.com/apache/thrift v0.13.0/go.mod h1:cp2SuWMxlEZw2r+iP2GNCdIi4C1qmUzdZFSVb+bacwQ= -github.com/aristanetworks/goarista v0.0.0-20170210015632-ea17b1a17847/go.mod h1:D/tb0zPVXnP7fmsLZjtdUhSsumbK/ij54UXjjVgMGxQ= github.com/armon/circbuf v0.0.0-20150827004946-bbbad097214e/go.mod h1:3U/XgcO3hCbHZ8TKRvWD2dDTCfh9M9ya+I9JpbB7O8o= github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8= github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da/go.mod h1:Q73ZrmVTwzkszR9V5SSuryQ31EELlFMUz1kKyl939pY= github.com/armon/go-metrics v0.3.9/go.mod h1:4O98XIr/9W0sxpJ8UaYkvjk10Iff7SnFrb4QAOwNTFc= +github.com/armon/go-metrics v0.3.10/go.mod h1:4O98XIr/9W0sxpJ8UaYkvjk10Iff7SnFrb4QAOwNTFc= github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8= +github.com/armon/go-radix v1.0.0/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8= github.com/aryann/difflib v0.0.0-20170710044230-e206f873d14a/go.mod h1:DAHtR1m6lCRdSC2Tm3DSWRPvIPr6xNKyeHdqDQSQT+A= github.com/aws/aws-lambda-go v1.13.3/go.mod h1:4UKl9IzQMoD+QF79YdCuzCwp8VbmG4VAQwij/eHl5CU= -github.com/aws/aws-sdk-go v1.25.48/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo= github.com/aws/aws-sdk-go v1.27.0/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo= +github.com/aws/aws-sdk-go v1.40.45/go.mod h1:585smgzpB/KqRA+K3y/NL/oYRqQvpNJYvLm+LY1U59Q= github.com/aws/aws-sdk-go-v2 v0.18.0/go.mod h1:JWVYvqSMppoMJC0x5wdwiImzgXTI9FuZwxzkQq9wy+g= +github.com/aws/aws-sdk-go-v2 v1.9.1/go.mod h1:cK/D0BBs0b/oWPIcX/Z/obahJK1TT7IPVjy53i/mX/4= +github.com/aws/aws-sdk-go-v2/service/cloudwatch v1.8.1/go.mod h1:CM+19rL1+4dFWnOQKwDc7H1KwXTz+h61oUSHyhV0b3o= +github.com/aws/smithy-go v1.8.0/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E= +github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA= github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q= github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8= github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs= github.com/bits-and-blooms/bitset v1.2.0/go.mod h1:gIdJ4wp64HaoK2YrL1Q5/N7Y16edYb8uY+O0FJTyyDA= github.com/bketelsen/crypt v0.0.3-0.20200106085610-5cbc8cc4026c/go.mod h1:MKsuJmJgSg28kpZDP6UIiPt0e0Oz0kqKNGyRaWEPv84= -github.com/bketelsen/crypt v0.0.4/go.mod h1:aI6NrJ0pMGgvZKL1iVgXLnfIFJtfV+bKCoqOes/6LfM= -github.com/btcsuite/btcd v0.0.0-20171128150713-2e60448ffcc6/go.mod h1:Dmm/EzmjnCiweXmzRIAiUWCInVmPgjkzgv5k4tVyXiQ= -github.com/btcsuite/btcd v0.0.0-20190115013929-ed77733ec07d/go.mod h1:d3C0AkH6BRcvO8T0UEPu53cnw4IbV63x1bEjildYhO0= -github.com/btcsuite/btcd v0.0.0-20190315201642-aa6e0f35703c/go.mod h1:DrZx5ec/dmnfpw9KyYoQyYo7d0KEvTkk/5M/vbZjAr8= github.com/btcsuite/btcd v0.20.1-beta/go.mod h1:wVuoA8VJLEcwgqHBwHmzLRazpKxTv13Px/pDuV7OomQ= github.com/btcsuite/btcd v0.21.0-beta/go.mod h1:ZSWyehm27aAuS9bvkATT+Xte3hjHZ+MRgMY/8NJ7K94= github.com/btcsuite/btcd v0.22.0-beta/go.mod h1:9n5ntfhhHQBIhUvlhDvD3Qg6fRUj4jkN0VB8L8svzOA= github.com/btcsuite/btclog v0.0.0-20170628155309-84c8d2346e9f/go.mod h1:TdznJufoqS23FtqVCzL0ZqgP5MqXbb4fg/WgDys70nA= -github.com/btcsuite/btcutil v0.0.0-20180706230648-ab6388e0c60a/go.mod h1:+5NJ2+qvTyV9exUAL/rxXi3DcLg2Ts+ymUAY5y4NvMg= -github.com/btcsuite/btcutil v0.0.0-20190207003914-4c204d697803/go.mod h1:+5NJ2+qvTyV9exUAL/rxXi3DcLg2Ts+ymUAY5y4NvMg= github.com/btcsuite/btcutil v0.0.0-20190425235716-9e5f4b9a998d/go.mod h1:+5NJ2+qvTyV9exUAL/rxXi3DcLg2Ts+ymUAY5y4NvMg= github.com/btcsuite/btcutil v1.0.2/go.mod h1:j9HUFwoQRsZL3V4n+qG+CUnEGHOarIxfC3Le2Yhbcts= github.com/btcsuite/btcutil v1.0.3-0.20201208143702-a53e38424cce/go.mod h1:0DVlHczLPewLcPGEIeUEzfOJhqGPQ0mJJRDBtD307+o= @@ -124,12 +125,15 @@ github.com/btcsuite/snappy-go v1.0.0/go.mod h1:8woku9dyThutzjeg+3xrA5iCpBRH8XEEg github.com/btcsuite/websocket v0.0.0-20150119174127-31079b680792/go.mod h1:ghJtEyQwv5/p4Mg4C0fgbePVuGr935/5ddU9Z3TmDRY= github.com/btcsuite/winsvc v1.0.0/go.mod h1:jsenWakMcC0zFBFurPLEAyrnc/teJEM1O46fmI40EZs= github.com/casbin/casbin/v2 v2.1.2/go.mod h1:YcPU1XXisHhLzuxH9coDNf2FbKpjGlbCg3n9yuLkIJQ= +github.com/casbin/casbin/v2 v2.37.0/go.mod h1:vByNa/Fchek0KZUgG5wEsl7iFsiviAYKRtgrQfcJqHg= github.com/cenkalti/backoff v2.2.1+incompatible/go.mod h1:90ReRw6GdpyfrHakVjL/QHaoyV4aDUVVkXQJJJ3NXXM= +github.com/cenkalti/backoff/v4 v4.1.1/go.mod h1:scbssz8iZGpm3xbr14ovlUdkxfGXNInqkPWOWmG2CLw= github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= -github.com/cespare/cp v0.1.0/go.mod h1:SOGHArjBr4JWaSDEVpWpo/hNg6RoKrls6Oh40hiwW+s= +github.com/census-instrumentation/opencensus-proto v0.3.0/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= github.com/cespare/xxhash v1.1.0 h1:a6HrQnmkObjyL+Gs60czilIUGqrzKutQD6XZog3p+ko= github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc= github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/cespare/xxhash/v2 v2.1.2/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/checkpoint-restore/go-criu/v5 v5.0.0/go.mod h1:cfwC0EG7HMUenopBsUf9d89JlCLQIfgVcNsNN0t6T2M= github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI= github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI= @@ -137,9 +141,9 @@ github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMn github.com/cilium/ebpf v0.6.2/go.mod h1:4tRaxcgiL706VnOzHOdBlY8IEAIdxINsQBcU4xJJXRs= github.com/circonus-labs/circonus-gometrics v2.3.1+incompatible/go.mod h1:nmEj6Dob7S7YxXgwXpfOuvO54S+tGdZdw9fuRZt25Ag= github.com/circonus-labs/circonusllhist v0.1.3/go.mod h1:kMXHVDlOchFAehlya5ePtbp5jckzBHf4XRpQvBOLI+I= +github.com/clbanning/mxj v1.8.4/go.mod h1:BVjHeAH+rl9rs6f+QIpeRl0tfu10SXn1pUSa5PVGJng= github.com/clbanning/x2j v0.0.0-20191024224557-825249438eec/go.mod h1:jMjuTZXRI4dUb/I5gc9Hdhagfvm9+RyrPryS/auMzxE= github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw= -github.com/cloudflare/cloudflare-go v0.10.2-0.20190916151808-a80f83b9add9/go.mod h1:1MxXX1Ux4x6mqPmjkUgTP1CdXIBXKX7T+Jk9Gxrmx+U= github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc= github.com/cncf/udpa/go v0.0.0-20200629203442-efcf912fb354/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= @@ -147,15 +151,17 @@ github.com/cncf/udpa/go v0.0.0-20210930031921-04548b0d99d4/go.mod h1:6pvJx4me5XP github.com/cncf/xds/go v0.0.0-20210312221358-fbca930ec8ed/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= github.com/cncf/xds/go v0.0.0-20210805033703-aa0b78936158/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= github.com/cncf/xds/go v0.0.0-20210922020428-25de7278fc84/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20211001041855-01bcc9b48dfe/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20211130200136-a8f946100490/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= github.com/cockroachdb/datadriven v0.0.0-20190809214429-80d97fb3cbaa/go.mod h1:zn76sxSg3SzpJ0PPJaLDCu+Bu0Lg3sKTORVIj19EIF8= github.com/codahale/hdrhistogram v0.0.0-20161010025455-3a0bb77429bd/go.mod h1:sE/e/2PUdi/liOCUjSTXgM1o87ZssimdTWN964YiIeI= -github.com/coinbase/rosetta-sdk-go v0.7.0/go.mod h1:7nD3oBPIiHqhRprqvMgPoGxe/nyq3yftRmpsy29coWE= github.com/confio/ics23/go v0.6.6/go.mod h1:E45NqnlpxGnpfTWL/xauN7MRwEE28T4Dd4uraToOaKg= github.com/confio/ics23/go v0.6.7-0.20220201201850-606d5105384e h1:GhCdFUgGIg9MC3vigJIhubUKE4VAYW6ZyEapsQ3HR6E= github.com/confio/ics23/go v0.6.7-0.20220201201850-606d5105384e/go.mod h1:E45NqnlpxGnpfTWL/xauN7MRwEE28T4Dd4uraToOaKg= github.com/containerd/console v1.0.2/go.mod h1:ytZPjGgY2oeTkAONYafi2kSj0aYggsf8acV1PGKCbzQ= github.com/containerd/continuity v0.0.0-20190827140505-75bee3e2ccb6/go.mod h1:GL3xCUCBDV3CZiTSEKksMWbLE66hEyuu9qyDOOqM47Y= +github.com/containerd/continuity v0.2.1/go.mod h1:wCYX+dRqZdImhGucXOqTQn05AhX6EUDaGEMUzTFFpLg= github.com/coreos/bbolt v1.3.2/go.mod h1:iRUV2dpdMOn7Bo10OQBFzIJO9kkE559Wcmn+qkEiiKk= github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE= github.com/coreos/etcd v3.3.13+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE= @@ -167,31 +173,26 @@ github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e/go.mod h1:F5haX7 github.com/coreos/go-systemd/v22 v22.3.2/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc= github.com/coreos/pkg v0.0.0-20160727233714-3ac0863d7acf/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA= github.com/coreos/pkg v0.0.0-20180928190104-399ea9e2e55f/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA= -github.com/cosmos/btcutil v1.0.4/go.mod h1:Ffqc8Hn6TJUdDgHBwIZLtrLQC1KdJ9jGJl/TvgUaxbU= -github.com/cosmos/cosmos-sdk v0.45.0 h1:DHD+CIRZ+cYgiLXuTEUL/aprnfPsWSwaww/fIZEsZlk= -github.com/cosmos/cosmos-sdk v0.45.0/go.mod h1:XXS/asyCqWNWkx2rW6pSuen+EVcpAFxq6khrhnZgHaQ= +github.com/cosmos/cosmos-sdk v0.45.6 h1:bnYLOcDp0cKWMLeUTTJIttq6xxRep52ulPxXC3BCfuQ= +github.com/cosmos/cosmos-sdk v0.45.6/go.mod h1:bPeeVMEtVvH3y3xAGHVbK+/CZlpaazzh77hG8ZrcJpI= github.com/cosmos/go-bip39 v0.0.0-20180819234021-555e2067c45d/go.mod h1:tSxLoYXyBmiFeKpvmq4dzayMdCjCnu8uqmCysIGBT2Y= -github.com/cosmos/go-bip39 v1.0.0/go.mod h1:RNJv0H/pOIVgxw6KS7QeX2a0Uo0aKUlfhZ4xuwvCdJw= github.com/cosmos/gorocksdb v1.2.0 h1:d0l3jJG8M4hBouIZq0mDUHZ+zjOx044J3nGRskwTb4Y= github.com/cosmos/gorocksdb v1.2.0/go.mod h1:aaKvKItm514hKfNJpUJXnnOWeBnk2GL4+Qw9NHizILw= github.com/cosmos/iavl v0.17.3 h1:s2N819a2olOmiauVa0WAhoIJq9EhSXE9HDBAoR9k+8Y= github.com/cosmos/iavl v0.17.3/go.mod h1:prJoErZFABYZGDHka1R6Oay4z9PrNeFFiMKHDAMOi4w= -github.com/cosmos/ledger-cosmos-go v0.11.1/go.mod h1:J8//BsAGTo3OC/vDLjMRFLW6q0WAaXvHnVc7ZmE8iUY= -github.com/cosmos/ledger-go v0.9.2/go.mod h1:oZJ2hHAZROdlHiwTg4t7kP+GKIIkBT+o6c9QWFanOyI= github.com/cpuguy83/go-md2man v1.0.10/go.mod h1:SmD6nW6nTyfqj6ABTjUi3V3JVMnlJmwcJI5acqYI6dE= github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU= github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU= +github.com/cpuguy83/go-md2man/v2 v2.0.1/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= github.com/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7DoTY= github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= github.com/cyphar/filepath-securejoin v0.2.2/go.mod h1:FpkQEhXnPnOthhzymB7CGsFk2G9VLXONKD9G7QGMM+4= -github.com/danieljoos/wincred v1.0.2/go.mod h1:SnuYRW9lp1oJrZX/dXJqr0cPK5gYXqx3EJbmjhLdK9U= github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/deckarep/golang-set v0.0.0-20180603214616-504e848d77ea/go.mod h1:93vsz/8Wt4joVM7c2AVqh+YRMiUSc14yDtF28KmMOgQ= github.com/decred/dcrd/lru v1.0.0/go.mod h1:mxKOwFd7lFjN2GZYsiz/ecgqR6kkYAl+0pz0tEMk218= -github.com/desertbit/timer v0.0.0-20180107155436-c41aec40b27f/go.mod h1:xH/i4TFMt8koVQZ6WFms69WAsDWr2XsYL3Hkl7jkoLE= +github.com/denisenkom/go-mssqldb v0.12.0/go.mod h1:iiK0YP1ZeepvmBQk/QpLEhhTNJgfzrpArPY/aFvc9yU= github.com/dgraph-io/badger/v2 v2.2007.2 h1:EjjK0KqwaFMlPin1ajhP943VPENHJdEz1KLIegjaI3k= github.com/dgraph-io/badger/v2 v2.2007.2/go.mod h1:26P/7fbL4kUZVEVKLAKXkBXKOydDmM2p1e+NhhnBCAE= github.com/dgraph-io/ristretto v0.0.3-0.20200630154024-f66de99634de/go.mod h1:KPxhHT9ZxKefz+PCeOGsrHpl1qZ7i70dGTu2u+Ahh6E= @@ -202,20 +203,15 @@ github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2/go.mod h1:SqUrOPUn github.com/dgryski/go-farm v0.0.0-20200201041132-a6ae2369ad13 h1:fAjc9m62+UWV/WAFKLNi6ZS0675eEUC9y3AlwSbQu1Y= github.com/dgryski/go-farm v0.0.0-20200201041132-a6ae2369ad13/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw= github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no= -github.com/dlclark/regexp2 v1.2.0/go.mod h1:2pZnwuY/m+8K6iRw6wQdMtk+rH5tNGR1i55kozfMjCc= -github.com/docker/docker v1.4.2-0.20180625184442-8e610b2b55bf/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk= +github.com/dnaeon/go-vcr v1.2.0/go.mod h1:R4UdLID7HZT3taECzJs4YgbbH6PIGXB6W/sc5OLb6RQ= github.com/docker/go-connections v0.4.0/go.mod h1:Gbd7IOopHjR8Iph03tsViu4nIes5XhDvyHbTtUxmeec= github.com/docker/go-units v0.4.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk= -github.com/dop251/goja v0.0.0-20200721192441-a695b0cdd498/go.mod h1:Mw6PkjjMXWbTj+nnj4s3QPXq1jaT0s5pC0iFD4+BOAA= github.com/dustin/go-humanize v0.0.0-20171111073723-bb3d318650d4/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= github.com/dustin/go-humanize v1.0.0 h1:VSnTsYCnlFHaM2/igO1h6X3HA71jcobQuxemgkq4zYo= github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= -github.com/dvsekhvalnov/jose2go v0.0.0-20200901110807-248326c1351b/go.mod h1:7BvyPhdbLxMXIYTFPLsyJRFMsKmOZnQmzh6Gb+uquuM= -github.com/dvyukov/go-fuzz v0.0.0-20200318091601-be3528f3a813/go.mod h1:11Gm+ccJnvAhCNLlf5+cS9KjtbaD5I5zaZpFMsTHWTw= github.com/eapache/go-resiliency v1.1.0/go.mod h1:kFI+JgMyC7bLPUVY133qvEBtVayf5mFgVsvEsIPBvNs= github.com/eapache/go-xerial-snappy v0.0.0-20180814174437-776d5712da21/go.mod h1:+020luEh2TKB4/GOp8oxxtq0Daoen/Cii55CzbTV6DU= github.com/eapache/queue v1.1.0/go.mod h1:6eCeP0CKFpHLu8blIFXhExK/dRa7WDZfr6jVFPTqq+I= -github.com/edsrzf/mmap-go v0.0.0-20160512033002-935e0e8a636c/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M= github.com/edsrzf/mmap-go v1.0.0/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M= github.com/envoyproxy/go-control-plane v0.6.9/go.mod h1:SBwIajubJHhxtWwsL9s8ss4safvEdbitLhGGK48rN6g= github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= @@ -226,62 +222,62 @@ github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.m github.com/envoyproxy/go-control-plane v0.9.9-0.20210217033140-668b12f5399d/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk= github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.mod h1:hliV/p42l8fGbc6Y9bQ70uLwIvmJyVE5k4iMKlh8wCQ= github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021/go.mod h1:AFq3mo9L8Lqqiid3OhADV3RfLJnjiw63cSpi+fDTRC0= +github.com/envoyproxy/go-control-plane v0.10.1/go.mod h1:AY7fTTXNdv/aJ2O5jwpxAPOWUZ7hQAEvzN5Pf27BkQQ= github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= -github.com/ethereum/go-ethereum v1.9.25/go.mod h1:vMkFiYLHI4tgPw4k2j4MHKoovchFE8plZ0M9VMk4/oM= +github.com/envoyproxy/protoc-gen-validate v0.6.2/go.mod h1:2t7qjJNvHPx8IjnBOzl9E9/baC+qXE/TeeyBRzgJDws= github.com/facebookgo/ensure v0.0.0-20160127193407-b4ab57deab51/go.mod h1:Yg+htXGokKKdzcwhuNDwVvN+uBxDGXJ7G/VN1d8fa64= github.com/facebookgo/ensure v0.0.0-20200202191622-63f1cf65ac4c h1:8ISkoahWXwZR41ois5lSJBSVw4D0OV19Ht/JSTzvSv0= github.com/facebookgo/stack v0.0.0-20160209184415-751773369052 h1:JWuenKqqX8nojtoVVWjGfOF9635RETekkoH6Cc9SX0A= github.com/facebookgo/stack v0.0.0-20160209184415-751773369052/go.mod h1:UbMTZqLaRiH3MsBH8va0n7s1pQYcu3uTb8G4tygF4Zg= github.com/facebookgo/subset v0.0.0-20150612182917-8dac2c3c4870/go.mod h1:5tD+neXqOorC30/tWg0LCSkrqj/AR6gu8yY8/fpw1q0= github.com/facebookgo/subset v0.0.0-20200203212716-c811ad88dec4 h1:7HZCaLC5+BZpmbhCOZJ293Lz68O7PYrF2EzeiFMwCLk= -github.com/fatih/color v1.3.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4= github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4= -github.com/fatih/color v1.10.0/go.mod h1:ELkj/draVOlAH/xkhN6mQ50Qd0MPOk5AAr3maGEBuJM= -github.com/felixge/httpsnoop v1.0.1/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= -github.com/fjl/memsize v0.0.0-20180418122429-ca190fb6ffbc/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0= +github.com/fatih/color v1.9.0/go.mod h1:eQcE1qtQxscV5RaZvpXrrb8Drkc3/DdQ+uUYCNjL+zU= +github.com/fatih/color v1.12.0/go.mod h1:ELkj/draVOlAH/xkhN6mQ50Qd0MPOk5AAr3maGEBuJM= +github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk= +github.com/fogleman/gg v1.2.1-0.20190220221249-0403632d5b90/go.mod h1:R/bRT+9gY/C5z7JzPU0zXsXHKM4/ayA+zqcVNZzPa1k= github.com/fortytw2/leaktest v1.3.0/go.mod h1:jDsjWgpAGjm2CA7WthBh/CdZYEPF31XHquHwclZch5g= github.com/franela/goblin v0.0.0-20200105215937-c9ffbefa60db/go.mod h1:7dvUGVsVBjqR7JHJk0brhHOZYGmfBYOrK0ZhYMEtBr4= +github.com/franela/goblin v0.0.0-20210519012713-85d372ac71e2/go.mod h1:VzmDKDJVZI3aJmnRI9VjAn9nJ8qPPsN1fqzr9dqInIo= github.com/franela/goreq v0.0.0-20171204163338-bcd34c9993f8/go.mod h1:ZhphrRTfi2rbfLwlschooIH4+wKKDR4Pdxhh+TRoA20= github.com/frankban/quicktest v1.11.3/go.mod h1:wRf/ReqHper53s+kmmSZizM8NamnL3IM0I9ntUbOk+k= github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= -github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4= github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ= -github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff/go.mod h1:x7DCsMOv1taUwEWCzT4cmDeAkigA5/QCwUodaVOe8Ww= +github.com/fsnotify/fsnotify v1.5.1 h1:mZcQUHVQUQWoPXXtuf9yuEXKudkV2sx1E06UadKWpgI= +github.com/fsnotify/fsnotify v1.5.1/go.mod h1:T3375wBYaZdLLcVNkcVbzGHY7f1l/uK5T5Ai1i3InKU= github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= -github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI= -github.com/gin-gonic/gin v1.6.3/go.mod h1:75u5sXoLsGZoRN5Sgbi1eraJ4GU3++wFwWzhwvtwp4M= github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU= github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as= github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as= github.com/go-kit/kit v0.10.0/go.mod h1:xUsJbQ/Fp4kEt7AFgCuvyX4a71u8h9jB8tj/ORgOZ7o= +github.com/go-kit/kit v0.12.0/go.mod h1:lHd+EkCZPIwYItmGDDRdhinkzX2A1sj+M9biaEaizzs= github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY= +github.com/go-kit/log v0.2.0/go.mod h1:NwTd00d/i8cPZ3xOwwiv2PO5MOcx78fFErGNcVmBjv0= github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE= github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk= github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A= -github.com/go-ole/go-ole v1.2.1/go.mod h1:7FAglXiTm7HKlQRDeOQ6ZNUHidzCWXuZWq/1dTyBNF8= -github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4= -github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8= -github.com/go-playground/universal-translator v0.17.0/go.mod h1:UkSxE5sNxxRwHyU+Scu5vgOQjsIJAF8j9muTVoKLVtA= -github.com/go-playground/validator/v10 v10.2.0/go.mod h1:uOYAAleCW8F/7oMFd6aG0GOhaH6EGOAJShg8Id5JGkI= -github.com/go-sourcemap/sourcemap v2.1.2+incompatible/go.mod h1:F8jJfvm2KbVjc5NqelyYJmf/v5J0dwNLS2mL4sNA1Jg= +github.com/go-logfmt/logfmt v0.5.1/go.mod h1:WYhtIu8zTZfxdn5+rREduYbwxfcBr/Vr6KEVveWlfTs= github.com/go-sql-driver/mysql v1.4.0/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w= +github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg= github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY= github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE= -github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee/go.mod h1:L0fX3K22YWvt/FAX9NnzrNzcI4wNYi9Yku4O0LKYflo= -github.com/gobwas/pool v0.2.0/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw= -github.com/gobwas/ws v1.0.2/go.mod h1:szmBTxLgaFppYjEmNtny/v3w89xOydFnnZMcgRRu/EM= -github.com/godbus/dbus v0.0.0-20190726142602-4481cbc300e2/go.mod h1:bBOAhwG1umN6/6ZUMtDFBMQR8jRg9O75tm9K00oMsK4= +github.com/go-zookeeper/zk v1.0.2/go.mod h1:nOB03cncLtlp4t+UAkGSV+9beXP/akpekBwL+UX1Qcw= github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= github.com/gogo/gateway v1.1.0/go.mod h1:S7rR8FRQyG3QFESeSv4l2WnsyzlCLG0CzBbUUo/mbic= github.com/gogo/googleapis v1.1.0/go.mod h1:gf4bu3Q80BeJ6H1S1vYPm8/ELATdvryBaNFGgqEef3s= +github.com/golang-jwt/jwt/v4 v4.0.0/go.mod h1:/xlHOz8bRuivTWchD4jCa+NbatV+wEUSzwAxVc6locg= +github.com/golang-sql/civil v0.0.0-20190719163853-cb61b32ac6fe/go.mod h1:8vg3r2VgvsThLBIFL93Qb5yWzgyZWhEmBwUJWevAkK0= +github.com/golang-sql/sqlexp v0.0.0-20170517235910-f1bb20e5a188/go.mod h1:vXjM/+wXQnTPR4KqTKDgJukSZ6amVRtWMPEjE6sQoK8= +github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k= github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= github.com/golang/groupcache v0.0.0-20160516000752-02826c3e7903/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20190129154638-5b532d6fd5ef/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y= @@ -292,7 +288,6 @@ github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71 github.com/golang/mock v1.5.0/go.mod h1:CWnOUgYIOo4TcNZ0wHX3YZCqsaM1I1Jvs6v3mP3KVu8= github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs= github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= -github.com/golang/protobuf v1.3.0/go.mod h1:Qd/q+1AKNOZr9uGQzbzCmRO6sUih6GTPZv6a1/R87v0= github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= @@ -312,8 +307,8 @@ github.com/golang/protobuf v1.5.2 h1:ROPKBNFfQgOUMifHyP+KYbvpjbdoFNs+aK7DXlji0Tw github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= -github.com/golang/snappy v0.0.3-0.20201103224600-674baa8c7fc3 h1:ur2rms48b3Ep1dxh7aUV2FZEQ8jEVO2F6ILKx8ofkAg= -github.com/golang/snappy v0.0.3-0.20201103224600-674baa8c7fc3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/golang/snappy v0.0.3 h1:fHPg5GQYlCeLIPB9BZqMVR5nR9A+IM5zcgeTdjMYmLA= +github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= github.com/google/btree v1.0.0 h1:0udJVsspx3VBr5FwtLhQQtuAsVc79tTq0ocGIPAU6qo= github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= @@ -327,14 +322,14 @@ github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/ github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU= github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/gofuzz v0.0.0-20170612174753-24818f796faf/go.mod h1:HP5RmnzzSNb993RKQDq4+1A4ia9nllfqcQFTQJedwGI= +github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= +github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= -github.com/google/gofuzz v1.1.1-0.20200604201612-c04b05f3adfa/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs= github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0= github.com/google/martian/v3 v3.1.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0= +github.com/google/martian/v3 v3.2.1/go.mod h1:oBOf6HBosgwRXnUGWUB05QECsc6uvmMiJ3+6W4l/CUk= github.com/google/orderedcode v0.0.1/go.mod h1:iVyU4/qPKHY5h/wSd6rZZCDcLJNxiWO6dvsYES2Sb20= github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= @@ -347,28 +342,27 @@ github.com/google/pprof v0.0.0-20201023163331-3e6fc7fc9c4c/go.mod h1:kpwsk12EmLe github.com/google/pprof v0.0.0-20201203190320-1bf35d6f28c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/pprof v0.0.0-20210122040257-d980be63207e/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20210601050228-01bbb1931b22/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20210609004039-a478d1d731e9/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20210720184732-4bb14d4b1be1/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg= github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk= +github.com/googleapis/gax-go/v2 v2.1.0/go.mod h1:Q3nei7sK6ybPYH7twZdmQpAd1MKb7pfu6SK+H1/DsU0= +github.com/googleapis/gax-go/v2 v2.1.1/go.mod h1:hddJymUZASv3XPyGkUpKj8pPO47Rmb0eJc8R6ouapiM= github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= -github.com/gordonklaus/ineffassign v0.0.0-20200309095847-7953dde2c7bf/go.mod h1:cuNKsD1zp2v6XfE/orVX2QE1LC+i254ceGcVeDT3pTU= github.com/gorilla/context v1.1.1/go.mod h1:kBGZzfjB9CEq2AlWe17Uuf7NDRt0dE0s8S51q0aT7Yg= -github.com/gorilla/handlers v1.5.1/go.mod h1:t8XrUpc4KVXb7HGyJ4/cEnwQiaxrX/hz1Zv/4g96P1Q= github.com/gorilla/mux v1.6.2/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs= github.com/gorilla/mux v1.7.3/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs= -github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So= github.com/gorilla/websocket v0.0.0-20170926233335-4201258b820c/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ= -github.com/gorilla/websocket v1.4.1-0.20190629185528-ae1634f6a989/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ= -github.com/gorilla/websocket v1.4.1/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= +github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ= github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= +github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= github.com/gotestyourself/gotestyourself v2.2.0+incompatible/go.mod h1:zZKM6oeNM8k+FRljX1mnzVYeS8wiGgQyvST1/GafPbY= -github.com/graph-gophers/graphql-go v0.0.0-20191115155744-f33e81362277/go.mod h1:9CQHMSxwO4MprSdzoIEobiHpoLtHm77vfxsvsIN5Vuc= github.com/grpc-ecosystem/go-grpc-middleware v1.0.0/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs= github.com/grpc-ecosystem/go-grpc-middleware v1.0.1-0.20190118093823-f849b5445de4/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs= -github.com/grpc-ecosystem/go-grpc-middleware v1.2.2/go.mod h1:EaizFBKfUKtMIF5iaDEhniwNedqGo9FuLFzppDr3uwI= github.com/grpc-ecosystem/go-grpc-middleware v1.3.0/go.mod h1:z0ButlSOZa5vEBq9m2m2hlwIgKw+rp3sdCBRoJY+30Y= github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk= github.com/grpc-ecosystem/grpc-gateway v1.8.5/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY= @@ -376,22 +370,31 @@ github.com/grpc-ecosystem/grpc-gateway v1.9.0/go.mod h1:vNeuVxBJEsws4ogUvrchl83t github.com/grpc-ecosystem/grpc-gateway v1.9.5/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY= github.com/grpc-ecosystem/grpc-gateway v1.16.0 h1:gmcG1KaJ57LophUzW0Hy8NmPhnMZb4M0+kPpLofRdBo= github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw= -github.com/gsterjov/go-libsecret v0.0.0-20161001094733-a6f4afe4910c/go.mod h1:NMPJylDgVpX0MLRlPy15sqSwOFv/U1GZ2m21JhFfek0= github.com/gtank/merlin v0.1.1-0.20191105220539-8318aed1a79f/go.mod h1:T86dnYJhcGOh5BjZFCJWTDeTK7XW8uE+E21Cy/bIQ+s= github.com/gtank/merlin v0.1.1/go.mod h1:T86dnYJhcGOh5BjZFCJWTDeTK7XW8uE+E21Cy/bIQ+s= github.com/gtank/ristretto255 v0.1.2/go.mod h1:Ph5OpO6c7xKUGROZfWVLiJf9icMDwUeIvY4OmlYW69o= github.com/hashicorp/consul/api v1.1.0/go.mod h1:VmuI/Lkw1nC05EYQWNKwWGbkg+FbDBtguAZLlVdkD9Q= github.com/hashicorp/consul/api v1.3.0/go.mod h1:MmDNSzIMUjNpY/mQ398R4bk2FnqQLoPndWW5VkKPlCE= +github.com/hashicorp/consul/api v1.10.1/go.mod h1:XjsvQN+RJGWI2TWy1/kqaE16HrR2J/FWgkYjdZQsX9M= +github.com/hashicorp/consul/api v1.12.0/go.mod h1:6pVBMo0ebnYdt2S3H87XhekM/HHrUoTD2XXb/VrZVy0= github.com/hashicorp/consul/sdk v0.1.1/go.mod h1:VKf9jXwCTEY1QZP2MOLRhb5i/I/ssyNV1vwHyQBF0x8= github.com/hashicorp/consul/sdk v0.3.0/go.mod h1:VKf9jXwCTEY1QZP2MOLRhb5i/I/ssyNV1vwHyQBF0x8= +github.com/hashicorp/consul/sdk v0.8.0/go.mod h1:GBvyrGALthsZObzUGsfgHZQDXjg4lOjagTIwIR1vPms= github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= github.com/hashicorp/go-cleanhttp v0.5.0/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80= github.com/hashicorp/go-cleanhttp v0.5.1/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80= +github.com/hashicorp/go-cleanhttp v0.5.2/go.mod h1:kO/YDlP8L1346E6Sodw+PrpBSV4/SoxCXGY6BqNFT48= +github.com/hashicorp/go-hclog v0.12.0/go.mod h1:whpDNt7SSdeAju8AWKIWsul05p54N/39EeqMAyrmvFQ= +github.com/hashicorp/go-hclog v0.16.2/go.mod h1:whpDNt7SSdeAju8AWKIWsul05p54N/39EeqMAyrmvFQ= +github.com/hashicorp/go-hclog v1.0.0/go.mod h1:whpDNt7SSdeAju8AWKIWsul05p54N/39EeqMAyrmvFQ= github.com/hashicorp/go-immutable-radix v1.0.0/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60= +github.com/hashicorp/go-immutable-radix v1.3.1/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60= github.com/hashicorp/go-msgpack v0.5.3/go.mod h1:ahLV/dePpqEmjfWmKiqvPkv/twdG7iPBM1vqhUKIvfM= github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk= +github.com/hashicorp/go-multierror v1.1.0/go.mod h1:spPvp8C1qA32ftKqdAHm4hHTbPw+vmowP0z+KUhOZdA= github.com/hashicorp/go-retryablehttp v0.5.3/go.mod h1:9B5zBasrRhHXnJnui7y6sL7es7NDiJgTc6Er0maI1Xs= github.com/hashicorp/go-rootcerts v1.0.0/go.mod h1:K6zTfqpRlCUIjkwsN4Z+hiSfzSTQa6eBIzfwKfwNnHU= +github.com/hashicorp/go-rootcerts v1.0.2/go.mod h1:pqUvnprVnM5bf7AOirdbb01K4ccR319Vf4pU3K5EGc8= github.com/hashicorp/go-sockaddr v1.0.0/go.mod h1:7Xibr9yA9JjQq1JpNB2Vw7kxv8xerXegt+ozgdvDeDU= github.com/hashicorp/go-syslog v1.0.0/go.mod h1:qPfqrKkXGihmCqbJM2mZgkZGvKG1dFdvsLplgctolz4= github.com/hashicorp/go-uuid v1.0.0/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro= @@ -404,26 +407,28 @@ github.com/hashicorp/golang-lru v0.5.4/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uG github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ= github.com/hashicorp/logutils v1.0.0/go.mod h1:QIAnNjmIWmVIIkWDTG1z5v++HQmx9WQRO+LraFDTW64= github.com/hashicorp/mdns v1.0.0/go.mod h1:tL+uN++7HEJ6SQLQ2/p+z2pH24WQKWjBPkE0mNTz8vQ= +github.com/hashicorp/mdns v1.0.1/go.mod h1:4gW7WsVCke5TE7EPeYliwHlRUyBtfCwuFwuMg2DmyNY= +github.com/hashicorp/mdns v1.0.4/go.mod h1:mtBihi+LeNXGtG8L9dX59gAEa12BDtBQSp4v/YAJqrc= github.com/hashicorp/memberlist v0.1.3/go.mod h1:ajVTdAv/9Im8oMAAj5G31PhhMCZJV2pPBoIllUwCN7I= +github.com/hashicorp/memberlist v0.2.2/go.mod h1:MS2lj3INKhZjWNqd3N0m3J+Jxf3DAOnAH9VT3Sh9MUE= +github.com/hashicorp/memberlist v0.3.0/go.mod h1:MS2lj3INKhZjWNqd3N0m3J+Jxf3DAOnAH9VT3Sh9MUE= github.com/hashicorp/serf v0.8.2/go.mod h1:6hOLApaqBFA1NXqRQAsxw9QxuDEvNxSQRwA/JwenrHc= -github.com/hdevalence/ed25519consensus v0.0.0-20210204194344-59a8610d2b87/go.mod h1:XGsKKeXxeRr95aEOgipvluMPlgjr7dGlk9ZTWOjcUcg= -github.com/holiman/uint256 v1.1.1/go.mod h1:y4ga/t+u+Xwd7CpDgZESaRcWy0I7XMlTMA25ApIH5Jw= +github.com/hashicorp/serf v0.9.5/go.mod h1:UWDWwZeL5cuWDJdl0C6wrvrUwEqtQ4ZKBKKENpqIUyk= +github.com/hashicorp/serf v0.9.6/go.mod h1:TXZNMjZQijwlDvp+r0b63xZ45H7JmCmgg4gpTwn9UV4= github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= github.com/hudl/fargo v1.3.0/go.mod h1:y3CKSmjA+wD2gak7sUSXTAoopbhU08POFhmITJgmKTg= -github.com/huin/goupnp v1.0.0/go.mod h1:n9v9KO1tAxYH82qOn+UTIFQDmx5n1Zxd/ClZDMX7Bnc= -github.com/huin/goutil v0.0.0-20170803182201-1ca381bf3150/go.mod h1:PpLOETDnJ0o3iZrZfqZzyLl6l7F3c6L1oWn7OICBi6o= +github.com/hudl/fargo v1.4.0/go.mod h1:9Ai6uvFy5fQNq6VPKtg+Ceq1+eTY4nKUlR2JElEOcDo= +github.com/iancoleman/strcase v0.2.0/go.mod h1:iwCmte+B7n89clKwxIoIXy/HfoL7AsD47ZCWhYzw7ho= github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= -github.com/improbable-eng/grpc-web v0.14.1/go.mod h1:zEjGHa8DAlkoOXmswrNvhUGEYQA9UI7DhrGeHR1DMGU= github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8= -github.com/influxdata/influxdb v1.2.3-0.20180221223340-01288bdb0883/go.mod h1:qZna6X/4elxqT3yI9iZYdZrWWdeFOOprn86kgg4+IzY= github.com/influxdata/influxdb1-client v0.0.0-20191209144304-8bf82d3c094d/go.mod h1:qj24IKcXYK6Iy9ceXlo3Tc+vtHo9lIhSX5JddghvEPo= -github.com/jackpal/go-nat-pmp v1.0.2-0.20160603034137-1fa385a6f458/go.mod h1:QPH045xvCAeXUZOxsnwmrtiCoxIr9eob+4orBN1SBKc= -github.com/jedisct1/go-minisign v0.0.0-20190909160543-45766022959e/go.mod h1:G1CVv03EnqU1wYL2dFwXxW2An0az9JTl/ZsqXQeBlkU= +github.com/influxdata/influxdb1-client v0.0.0-20200827194710-b269163b24ab/go.mod h1:qj24IKcXYK6Iy9ceXlo3Tc+vtHo9lIhSX5JddghvEPo= github.com/jessevdk/go-flags v0.0.0-20141203071132-1679536dcc89/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI= github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI= -github.com/jhump/protoreflect v1.9.0/go.mod h1:7GcYQDdMU/O/BBrl/cX6PNHpXh6cenjd8pneu5yW7Tg= github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k= +github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo= +github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U= github.com/jmhodges/levigo v1.0.0 h1:q5EC36kV79HWeTBWsod3mG11EgStG3qArTKcvlksN1U= github.com/jmhodges/levigo v1.0.0/go.mod h1:Q6Qx+uH3RAqyK4rFQroq9RL7mdkABMcfhEI+nNuzMJQ= github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo= @@ -435,19 +440,18 @@ github.com/json-iterator/go v1.1.8/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/u github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= github.com/json-iterator/go v1.1.11/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= +github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU= github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk= github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU= -github.com/julienschmidt/httprouter v1.1.1-0.20170430222011-975b5c4c7c21/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w= github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w= github.com/julienschmidt/httprouter v1.3.0/go.mod h1:JR6WtHb+2LUe8TCKY3cZOxFyyO8IZAc4RVcycCCAKdM= -github.com/karalabe/usb v0.0.0-20190919080040-51dc0efba356/go.mod h1:Od972xHfMJowv7NGVDiWVxk2zxnWgjLlJzE+F4F7AGU= -github.com/keybase/go-keychain v0.0.0-20190712205309-48d3d31d256d/go.mod h1:JJNrCn9otv/2QP4D7SMJBgaleKpOf66PnW6F5WGNRIc= +github.com/jung-kurt/gofpdf v1.0.3-0.20190309125859-24315acbbda5/go.mod h1:7Id9E/uU8ce6rXgefFLlgrJj/GYY22cpxn+r32jIOes= github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= github.com/kkdai/bstream v0.0.0-20161212061736-f391b8402d23/go.mod h1:J+Gs4SYgM6CZQHDETBtE9HaSEkGmuNXF86RwHhHUvq4= -github.com/klauspost/compress v1.10.3/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs= -github.com/klauspost/compress v1.11.7/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs= +github.com/klauspost/compress v1.13.4/go.mod h1:8dP1Hq4DHOhN9w426knH3Rhby4rFm6D8eO+e+Dq5Gzg= +github.com/klauspost/compress v1.13.6/go.mod h1:/3/Vjq9QcHkK5uEr5lBEmyoZ1iFhe47etQ6QUkpK6sk= github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg= @@ -458,38 +462,43 @@ github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfn github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= -github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= github.com/lazyledger/smt v0.2.1-0.20210709230900-03ea40719554 h1:nDOkLO7klmnEw1s4AyKt1Arvpgyh33uj1JmkYlJaDsk= github.com/lazyledger/smt v0.2.1-0.20210709230900-03ea40719554/go.mod h1:9+Pb2/tg1PvEgW7aFx4bFhDE4bvbI03zuJ8kb7nJ9Jc= -github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII= github.com/lib/pq v1.2.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo= -github.com/lib/pq v1.10.2/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o= +github.com/lib/pq v1.10.4/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o= github.com/libp2p/go-buffer-pool v0.0.2/go.mod h1:MvaB6xw5vOrDl8rYZGLFdKAuk/hRoRZd1Vi32+RXyFM= github.com/lightstep/lightstep-tracer-common/golang/gogo v0.0.0-20190605223551-bc2310a04743/go.mod h1:qklhhLq1aX+mtWk9cPHPzaBjWImj5ULL6C7HFJtXQMM= github.com/lightstep/lightstep-tracer-go v0.18.1/go.mod h1:jlF1pusYV4pidLvZ+XD0UBX0ZE6WURAspgAczcDHrL4= -github.com/lucasjones/reggen v0.0.0-20180717132126-cdb49ff09d77/go.mod h1:5ELEyG+X8f+meRWHuqUOewBOhvHkl7M76pdGEansxW4= +github.com/lyft/protoc-gen-star v0.5.3/go.mod h1:V0xaHgaf5oCCqmcxYcWiDfTiKsZsRc87/1qhoTACD8w= github.com/lyft/protoc-gen-validate v0.0.13/go.mod h1:XbGvPuh87YZc5TdIa2/I4pLk0QoUACkjt2znoq26NVQ= github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ= github.com/magiconair/properties v1.8.1/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ= github.com/magiconair/properties v1.8.5/go.mod h1:y3VJvCyxH9uVvJTWEGAELF3aiYNyPKd5NZ3oSwXrF60= github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU= -github.com/mattn/go-colorable v0.1.0/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU= +github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE= +github.com/mattn/go-colorable v0.1.6/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= -github.com/mattn/go-ieproxy v0.0.0-20190610004146-91bb50d98149/go.mod h1:31jz6HNzdxOmlERGGEc4v/dMssOfmp2p5bT/okiKFFc= -github.com/mattn/go-ieproxy v0.0.0-20190702010315-6dee0af9227d/go.mod h1:31jz6HNzdxOmlERGGEc4v/dMssOfmp2p5bT/okiKFFc= +github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= +github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4= github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4= github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4= -github.com/mattn/go-isatty v0.0.5-0.20180830101745-3fb116b82035/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4= +github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= +github.com/mattn/go-isatty v0.0.10/go.mod h1:qgIWMr58cqv1PHHyhnkY9lrL7etaEgOFcMEpPG5Rm84= +github.com/mattn/go-isatty v0.0.11/go.mod h1:PhnuNfih5lzO57/f3n+odYbM4JtupLOxQOAqxQCu2WE= github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU= github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94= github.com/mattn/go-runewidth v0.0.2/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU= -github.com/mattn/go-runewidth v0.0.3/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU= -github.com/mattn/go-runewidth v0.0.4/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU= +github.com/mattn/go-sqlite3 v1.14.9/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU= github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0= github.com/miekg/dns v1.0.14/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg= +github.com/miekg/dns v1.1.26/go.mod h1:bPDLeHnStXmXAq1m/Ch/hvfNHr14JKNPMBo3VZKjuso= +github.com/miekg/dns v1.1.41/go.mod h1:p6aan82bvRIyn+zDIv9xYNUpwa73JcSh9BKwknJysuI= +github.com/miekg/dns v1.1.43/go.mod h1:+evo5L0630/F6ca/Z9+GAqzhjGyn8/c+TBaOyfEl0V4= github.com/mimoo/StrobeGo v0.0.0-20181016162300-f8f6d4d2b643/go.mod h1:43+3pMjjKimDBf5Kr4ZFNGbLql1zKkbImw+fZbw3geM= github.com/minio/highwayhash v1.0.1/go.mod h1:BQskDq+xkJ12lmlUUi7U0M5Swg3EWR+dLTk+kldvVxY= +github.com/minio/highwayhash v1.0.2/go.mod h1:BQskDq+xkJ12lmlUUi7U0M5Swg3EWR+dLTk+kldvVxY= github.com/mitchellh/cli v1.0.0/go.mod h1:hNIlj7HEI86fIcpObd7a0FcrxTWetlwJDGcceTlRvqc= +github.com/mitchellh/cli v1.1.0/go.mod h1:xcISNoH86gajksDmfB23e/pu+B+GeFRMYmoHXxx3xhI= github.com/mitchellh/go-homedir v1.0.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0= github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0= github.com/mitchellh/go-testing-interface v1.0.0/go.mod h1:kRemZodwjscx+RGhAo8eIhFbs2+BFgRtFPeD/KE+zxI= @@ -497,30 +506,32 @@ github.com/mitchellh/gox v0.4.0/go.mod h1:Sd9lOJ0+aimLBi73mGofS1ycjY8lL3uZM3JPS4 github.com/mitchellh/iochan v1.0.0/go.mod h1:JwYml1nuB7xOzsp52dPpHFffvOCDupsG0QubkSMEySY= github.com/mitchellh/mapstructure v0.0.0-20160808181253-ca63d7c062ee/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y= github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y= -github.com/mitchellh/mapstructure v1.3.3/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= -github.com/mitchellh/mapstructure v1.4.1/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= +github.com/mitchellh/mapstructure v1.4.2/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= +github.com/mitchellh/mapstructure v1.4.3/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= github.com/moby/sys/mountinfo v0.4.1/go.mod h1:rEr8tzG/lsIZHBtN/JjGG+LMYx9eXgW2JI+6q0qou+A= github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= +github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= +github.com/modocache/gover v0.0.0-20171022184752-b58185e213c5/go.mod h1:caMODM3PzxT8aQXRPkAt8xlV/e7d7w8GM5g0fa5F0D8= github.com/mrunalp/fileutils v0.5.0/go.mod h1:M1WthSahJixYnrXQl/DFQuteStB1weuxD2QJNHXfbSQ= -github.com/mtibben/percent v0.2.1/go.mod h1:KG9uO+SZkUp+VkRHsCdYQV3XSZrrSpR3O9ibNBTZrns= github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U= github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U= -github.com/mwitkow/grpc-proxy v0.0.0-20181017164139-0f1106ef9c76/go.mod h1:x5OoJHDHqxHS801UIuhqGl6QdSAEJvtausosHSdazIo= -github.com/naoina/go-stringutil v0.1.0/go.mod h1:XJ2SJL9jCtBh+P9q5btrd/Ylo8XwT/h1USek5+NqSA0= -github.com/naoina/toml v0.1.2-0.20170918210437-9fafd6967416/go.mod h1:NBIhNtsFMo3G2szEBne+bO4gS192HuIYRqfvOWb4i1E= github.com/nats-io/jwt v0.3.0/go.mod h1:fRYCDE99xlTsqUzISS1Bi75UBJ6ljOJQOAAu5VglpSg= github.com/nats-io/jwt v0.3.2/go.mod h1:/euKqTS1ZD+zzjYrY7pseZrTtWQSjujC7xjPc8wL6eU= +github.com/nats-io/jwt v1.2.2/go.mod h1:/xX356yQA6LuXI9xWW7mZNpxgF2mBmGecH+Fj34sP5Q= +github.com/nats-io/jwt/v2 v2.0.3/go.mod h1:VRP+deawSXyhNjXmxPCHskrR6Mq50BqpEI5SEcNiGlY= github.com/nats-io/nats-server/v2 v2.1.2/go.mod h1:Afk+wRZqkMQs/p45uXdrVLuab3gwv3Z8C4HTBu8GD/k= +github.com/nats-io/nats-server/v2 v2.5.0/go.mod h1:Kj86UtrXAL6LwYRA6H4RqzkHhK0Vcv2ZnKD5WbQ1t3g= github.com/nats-io/nats.go v1.9.1/go.mod h1:ZjDU1L/7fJ09jvUSRVBR2e7+RnLiiIQyqyzEE/Zbp4w= +github.com/nats-io/nats.go v1.12.1/go.mod h1:BPko4oXsySz4aSWeFgOHLZs3G4Jq4ZAyE6/zMCxRT6w= github.com/nats-io/nkeys v0.1.0/go.mod h1:xpnFELMwJABBLVhffcfd1MZx6VsNRFpEugbxziKVo7w= github.com/nats-io/nkeys v0.1.3/go.mod h1:xpnFELMwJABBLVhffcfd1MZx6VsNRFpEugbxziKVo7w= +github.com/nats-io/nkeys v0.2.0/go.mod h1:XdZpAbhgyyODYqjTawOnIOI7VlbKSarI9Gfy1tqEu/s= +github.com/nats-io/nkeys v0.3.0/go.mod h1:gvUNGjVcM2IPr5rCsRsC6Wb3Hr2CQAm08dsxtV6A5y4= github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c= -github.com/neilotoole/errgroup v0.1.5/go.mod h1:Q2nLGf+594h0CLBs/Mbg6qOr7GtqDK7C2S41udRnToE= github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno= -github.com/nishanths/predeclared v0.0.0-20200524104333-86fad755b4d3/go.mod h1:nt3d53pc1VYcphSCIaYAJtnPYnr3Zyn8fMq2wvPGPso= github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A= github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE= github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU= @@ -528,15 +539,12 @@ github.com/oklog/oklog v0.3.2/go.mod h1:FCV+B7mhrz4o+ueLpx+KqkyXRGMWOYEvfiXtdGtb github.com/oklog/run v1.0.0/go.mod h1:dlhp/R75TPv97u0XWUtDeV/lRKWPKSdTuV0TZvrmrQA= github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U= github.com/olekukonko/tablewriter v0.0.0-20170122224234-a0225b3f23b5/go.mod h1:vsDQFd/mU46D+Z4whnwzcISnGGzXWMclvtLoiIKAKIo= -github.com/olekukonko/tablewriter v0.0.1/go.mod h1:vsDQFd/mU46D+Z4whnwzcISnGGzXWMclvtLoiIKAKIo= -github.com/olekukonko/tablewriter v0.0.2-0.20190409134802-7e037d187b0c/go.mod h1:vsDQFd/mU46D+Z4whnwzcISnGGzXWMclvtLoiIKAKIo= github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk= github.com/onsi/ginkgo v1.14.0/go.mod h1:iSB4RoI2tjJc9BBv4NKIKWKya62Rps+oPG/Lv9klQyY= github.com/onsi/ginkgo v1.16.2/go.mod h1:CObGmKUOKaSC0RjmoAK7tKyn4Azo5P2IWuoMnvwxz1E= github.com/onsi/ginkgo v1.16.4 h1:29JGrr5oVBm5ulCWet69zQkzWipVXIol6ygQUe/EzNc= -github.com/onsi/ginkgo v1.16.4/go.mod h1:dX+/inL/fNMqNlz0e9LfyB9TswhZpCVdJM/Z6Vvnwo0= github.com/onsi/gomega v1.4.1/go.mod h1:C1qb7wdrVGGVU+Z6iS04AVkA3Q65CEZX59MT0QO5uiA= github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY= github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY= @@ -545,38 +553,39 @@ github.com/onsi/gomega v1.13.0 h1:7lLHu94wT9Ij0o6EWWclhu0aOh32VxhkwEJvzuWPeak= github.com/onsi/gomega v1.13.0/go.mod h1:lRk9szgn8TxENtWd0Tp4c3wjlRfMTMH27I+3Je41yGY= github.com/op/go-logging v0.0.0-20160315200505-970db520ece7/go.mod h1:HzydrMdWErDVzsI23lYNej1Htcns9BCg93Dk0bBINWk= github.com/opencontainers/go-digest v1.0.0-rc1/go.mod h1:cMLVZDEM3+U2I4VmLI6N8jQYUd2OVphdqWwCJHrFt2s= +github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM= github.com/opencontainers/image-spec v1.0.1/go.mod h1:BtxoFyWECRxE4U/7sNtV5W15zMzWCbyJoFRP3s7yZA0= +github.com/opencontainers/image-spec v1.0.2/go.mod h1:BtxoFyWECRxE4U/7sNtV5W15zMzWCbyJoFRP3s7yZA0= github.com/opencontainers/runc v0.1.1/go.mod h1:qT5XzbpPznkRYVz/mWwUaVBUv2rmF59PVA73FjuZG0U= github.com/opencontainers/runc v1.0.2/go.mod h1:aTaHFFwQXuA71CiyxOdFFIorAoemI04suvGRQFzWTD0= +github.com/opencontainers/runc v1.0.3/go.mod h1:aTaHFFwQXuA71CiyxOdFFIorAoemI04suvGRQFzWTD0= github.com/opencontainers/runtime-spec v1.0.3-0.20210326190908-1c3f411f0417/go.mod h1:jwyrGlmzljRJv/Fgzds9SsS/C5hL+LL3ko9hs6T5lQ0= github.com/opencontainers/selinux v1.8.2/go.mod h1:MUIHuUEvKB1wtJjQdOyYRgOnLD2xAPP8dBsCoU0KuF8= github.com/opentracing-contrib/go-observer v0.0.0-20170622124052-a52f23424492/go.mod h1:Ngi6UdF0k5OKD5t5wlmGhe/EDKPoUM3BXZSSfIuJbis= github.com/opentracing/basictracer-go v1.0.0/go.mod h1:QfBfYuafItcjQuMwinw9GhYKwFXS9KnPs5lxoYwgW74= github.com/opentracing/opentracing-go v1.0.2/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o= github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o= +github.com/opentracing/opentracing-go v1.2.0/go.mod h1:GxEUsuufX4nBwe+T+Wl9TAgYrxe9dPLANfrWvHYVTgc= github.com/openzipkin-contrib/zipkin-go-opentracing v0.4.5/go.mod h1:/wsWhb9smxSfWAKL3wpBW7V8scJMt8N8gnaMCS9E/cA= github.com/openzipkin/zipkin-go v0.1.6/go.mod h1:QgAqvLzwWbR/WpD4A3cGpPtJrZXNIiJc5AZX7/PBEpw= github.com/openzipkin/zipkin-go v0.2.1/go.mod h1:NaW6tEwdmWMaCDZzg8sh+IBNOxHMPnhQw8ySjnjRyN4= github.com/openzipkin/zipkin-go v0.2.2/go.mod h1:NaW6tEwdmWMaCDZzg8sh+IBNOxHMPnhQw8ySjnjRyN4= +github.com/openzipkin/zipkin-go v0.2.5/go.mod h1:KpXfKdgRDnnhsxw4pNIH9Md5lyFqKUa4YDFlwRYAMyE= github.com/ory/dockertest v3.3.5+incompatible/go.mod h1:1vX4m9wsvi00u5bseYwXaSnhNrne+V0E6LAcBILJdPs= -github.com/otiai10/copy v1.6.0/go.mod h1:XWfuS3CrI0R6IE0FbgHsEazaXO8G0LpMp9o8tos0x4E= -github.com/otiai10/curr v0.0.0-20150429015615-9b4961190c95/go.mod h1:9qAhocn7zKJG+0mI8eUu6xqkFDYS2kb2saOteoSB3cE= -github.com/otiai10/curr v1.0.0/go.mod h1:LskTG5wDwr8Rs+nNQ+1LlxRjAtTZZjtJW4rMXl6j4vs= -github.com/otiai10/mint v1.3.0/go.mod h1:F5AjcsTsWUqX+Na9fpHb52P8pcRX2CI6A3ctIT91xUo= -github.com/otiai10/mint v1.3.2/go.mod h1:/yxELlJQ0ufhjUwhshSj+wFjZ78CnZ48/1wtmBH1OTc= github.com/pact-foundation/pact-go v1.0.4/go.mod h1:uExwJY4kCzNPcHRj+hCR/HBbOOIwwtUjcrb0b5/5kLM= github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc= github.com/pascaldekloe/goe v0.1.0/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc= -github.com/pborman/uuid v0.0.0-20170112150404-1b00554d8222/go.mod h1:VyrYX9gd7irzKovcSS6BIIEwPRkP2Wm2m9ufcdFSJ34= github.com/pborman/uuid v1.2.0/go.mod h1:X/NO0urCmaxf9VXbdlT7C2Yzkj2IKimNn4k+gtPdI/k= github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic= -github.com/pelletier/go-toml v1.9.3/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCkoOuaOx1Y+c= +github.com/pelletier/go-toml v1.9.4/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCkoOuaOx1Y+c= github.com/performancecopilot/speed v3.0.0+incompatible/go.mod h1:/CLtqpZ5gBg1M9iaPbIdPPGyKcA8hKdoy6hAWba7Yac= -github.com/peterh/liner v1.1.1-0.20190123174540-a2c9a5303de7/go.mod h1:CRroGNssyjTd/qIG2FyxByd2S8JEAZXBl4qUrZf8GS0= +github.com/performancecopilot/speed/v4 v4.0.0/go.mod h1:qxrSyuDGrTOWfV+uKRFhfxw6h/4HXRGUiZiufxo49BM= github.com/petermattis/goid v0.0.0-20180202154549-b0b1615b78e5 h1:q2e307iGHPdTGp0hoxKjt1H5pDo6utceo3dQVK3I5XQ= github.com/petermattis/goid v0.0.0-20180202154549-b0b1615b78e5/go.mod h1:jvVRKCrJTQWu0XVbaOlby/2lO20uSCHEMzzplHXte1o= +github.com/philhofer/fwd v1.1.1/go.mod h1:gk3iGcWd9+svBvR0sR+KPcfE+RNWozjowpeBVG3ZVNU= github.com/pierrec/lz4 v1.0.2-0.20190131084431-473cd7ce01a1/go.mod h1:3/3N9NVKO0jef7pBehbT1qWhCMrIgbYNnFAZCqQ5LRc= github.com/pierrec/lz4 v2.0.5+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY= +github.com/pkg/browser v0.0.0-20180916011732-0a3d74bf9ce4/go.mod h1:4OwLy04Bl9Ef3GJJCoec+30X3LQs/0/m4HFRt/2LUSA= github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= @@ -586,6 +595,7 @@ github.com/pkg/sftp v1.10.1/go.mod h1:lYOWFsE0bwd1+KfKJaKeuokY15vzFx25BLbzYYoAxZ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI= +github.com/posener/complete v1.2.3/go.mod h1:WZIdtGGp+qx0sLrYKtIRAruyNpv6hFCicSgv7Sy7s/s= github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw= github.com/prometheus/client_golang v0.9.3-0.20190127221311-3c4408c8b829/go.mod h1:p2iRAGwDERtqlqzRXnrOVns+ignqQo//hLXqYxZYVNs= github.com/prometheus/client_golang v0.9.3/go.mod h1:/TN21ttK/J9q6uSwhBd54HahCDft0ttaMvbicHlPoso= @@ -595,6 +605,7 @@ github.com/prometheus/client_golang v1.4.0/go.mod h1:e9GMxYsXl05ICDXkRhurwBS4Q3O github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M= github.com/prometheus/client_golang v1.8.0/go.mod h1:O9VU6huf47PktckDQfMTX0Y8tY0/7TSWwj+ITvv0TnM= github.com/prometheus/client_golang v1.11.0/go.mod h1:Z6t4BnS23TR94PD6BsDNk8yVqroYurpAkEiz0P2BEV0= +github.com/prometheus/client_golang v1.12.1/go.mod h1:3Z9XVyYiZYEO+YQWt3RD2R3jrbd179Rt297l4aS6nDY= github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo= github.com/prometheus/client_model v0.0.0-20190115171406-56726106282f/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo= github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= @@ -609,9 +620,9 @@ github.com/prometheus/common v0.7.0/go.mod h1:DjGbpBbp5NYNiECxcL/VnbXCCaQpKd3tt2 github.com/prometheus/common v0.9.1/go.mod h1:yhUN8i9wzaXS3w1O07YhxHEBxD+W35wd8bs7vj7HSQ4= github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo= github.com/prometheus/common v0.14.0/go.mod h1:U+gB1OBLb1lF3O42bTCL+FK18tX9Oar16Clt/msog/s= -github.com/prometheus/common v0.15.0/go.mod h1:U+gB1OBLb1lF3O42bTCL+FK18tX9Oar16Clt/msog/s= github.com/prometheus/common v0.26.0/go.mod h1:M7rCNAaPfAosfx8veZJCuw84e35h3Cfd9VFqTh1DIvc= -github.com/prometheus/common v0.29.0/go.mod h1:vu+V0TpY+O6vW9J44gczi3Ap/oXXR10b+M/gUGO4Hls= +github.com/prometheus/common v0.30.0/go.mod h1:vu+V0TpY+O6vW9J44gczi3Ap/oXXR10b+M/gUGO4Hls= +github.com/prometheus/common v0.32.1/go.mod h1:vu+V0TpY+O6vW9J44gczi3Ap/oXXR10b+M/gUGO4Hls= github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk= github.com/prometheus/procfs v0.0.0-20190117184657-bf6a532e95b1/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk= github.com/prometheus/procfs v0.0.0-20190507164030-5867b95ac084/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA= @@ -619,35 +630,28 @@ github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsT github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A= github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU= github.com/prometheus/procfs v0.2.0/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU= -github.com/prometheus/procfs v0.3.0/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU= github.com/prometheus/procfs v0.6.0/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA= -github.com/prometheus/tsdb v0.6.2-0.20190402121629-4f204dcbc150/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU= +github.com/prometheus/procfs v0.7.3/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA= github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU= -github.com/rakyll/statik v0.1.7/go.mod h1:AlZONWzMtEnMs7W4e/1LURLiI49pIMmp6V9Unghqrcc= github.com/rcrowley/go-metrics v0.0.0-20181016184325-3113b8401b8a/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4= github.com/rcrowley/go-metrics v0.0.0-20200313005456-10cdbea86bc0/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4= -github.com/regen-network/cosmos-proto v0.3.1/go.mod h1:jO0sVX6a1B36nmE8C9xBFXpNwWejXC7QqCOnH3O0+YM= github.com/regen-network/protobuf v1.3.3-alpha.regen.1 h1:OHEc+q5iIAXpqiqFKeLpu5NwTIkVXUs48vFMwzqpqY4= github.com/regen-network/protobuf v1.3.3-alpha.regen.1/go.mod h1:2DjTFR1HhMQhiWC5sZ4OhQ3+NtdbZ6oBDKQwq5Ou+FI= -github.com/rjeczalik/notify v0.9.1/go.mod h1:rKwnCoCGeuQnwBtTSPL9Dad03Vh2n40ePRrjvIXnJho= github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg= github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ= github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= -github.com/rs/cors v0.0.0-20160617231935-a62a804a8a00/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU= github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU= -github.com/rs/xhandler v0.0.0-20160618193221-ed27b6fd6521/go.mod h1:RvLn4FgxWubrpZHtQLnOf6EwhN2hEMusxZOhcW9H3UQ= -github.com/rs/xid v1.2.1/go.mod h1:+uKXf+4Djp6Md1KODXJxgGQPKngRmWyn10oCKFzNHOQ= -github.com/rs/zerolog v1.23.0/go.mod h1:6c7hFfxPOy7TacJc4Fcdi24/J0NKYGzjG8FWRI916Qo= +github.com/rs/cors v1.8.2/go.mod h1:XyqrcTp5zjWr1wsJ8PIRZssZ8b/WMcMf71DJnit4EMU= github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g= github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= +github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= github.com/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts= +github.com/sagikazarmark/crypt v0.4.0/go.mod h1:ALv2SRj7GxYV4HO9elxH9nS6M9gW+xDNxqmyJ6RfDFM= github.com/samuel/go-zookeeper v0.0.0-20190923202752-2cc03de413da/go.mod h1:gi+0XIa01GRL2eRQVjQkKGqKF3SF9vZR/HnPullcV2E= github.com/sasha-s/go-deadlock v0.2.1-0.20190427202633-1595213edefa h1:0U2s5loxrTy6/VgfVoLuVLFJcURKLH49ie0zSch7gh4= github.com/sasha-s/go-deadlock v0.2.1-0.20190427202633-1595213edefa/go.mod h1:F73l+cr82YSh10GxyRI6qZiCgK64VaZjwesgfQ1/iLM= github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc= github.com/seccomp/libseccomp-golang v0.9.1/go.mod h1:GbW5+tmTXfcxTToHLXlScSlAvWlF4P2Ca7zGrPiEpWo= -github.com/segmentio/fasthash v1.0.3/go.mod h1:waKX8l2N8yckOgmSsXJi7x1ZfdKZ4x7KRMzBtS3oedY= -github.com/shirou/gopsutil v2.20.5+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA= github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc= github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo= github.com/sirupsen/logrus v1.4.1/go.mod h1:ni0Sbl8bgC9z8RoU9G6nDWqqs/fq4eDPysMBDgk/93Q= @@ -664,79 +668,71 @@ github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasO github.com/spaolacci/murmur3 v1.1.0 h1:7c1g84S4BPRrfL5Xrdp6fOJ206sU9y293DDHaoy0bLI= github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ= +github.com/spf13/afero v1.3.3/go.mod h1:5KUK8ByomD5Ti5Artl0RtHeI5pTF7MIDuXL3yY520V4= github.com/spf13/afero v1.6.0/go.mod h1:Ai8FlHk4v/PARR026UzYexafAt9roJ7LcLMAmO6Z93I= github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE= -github.com/spf13/cast v1.3.1/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE= +github.com/spf13/cast v1.4.1/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE= github.com/spf13/cobra v0.0.3/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ= github.com/spf13/cobra v0.0.5/go.mod h1:3K3wKZymM7VvHMDS9+Akkh4K60UwM26emMESw8tLCHU= +github.com/spf13/cobra v1.0.0/go.mod h1:/6GTrnGXV9HjY+aR4k0oJ5tcvakLuG6EuKReYlHNrgE= github.com/spf13/cobra v1.1.1/go.mod h1:WnodtKOvamDL/PwE2M4iKs8aMDBZ5Q5klgD3qfVJQMI= -github.com/spf13/cobra v1.2.1/go.mod h1:ExllRjgxM/piMAM+3tAZvg8fsklGAf3tPfi+i8t68Nk= +github.com/spf13/cobra v1.4.0/go.mod h1:Wo4iy3BUC+X2Fybo0PDqwJIv3dNRiZLHQymsfxlB84g= github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo= github.com/spf13/jwalterweatherman v1.1.0/go.mod h1:aNWZUN0dPAAO/Ljvb5BEdw96iTZ0EXowPYD95IqWIGo= github.com/spf13/pflag v1.0.1/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4= github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4= github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= github.com/spf13/viper v1.3.2/go.mod h1:ZiWeW+zYFKm7srdB9IoDzzZXaJaI5eL9QjNiN/DMA2s= +github.com/spf13/viper v1.4.0/go.mod h1:PTJ7Z/lr49W6bUbkmS1V3by4uWynFiR9p7+dSq/yZzE= github.com/spf13/viper v1.7.0/go.mod h1:8WkrPz2fc9jxqZNCJI/76HCieCp4Q8HaLFoCha5qpdg= github.com/spf13/viper v1.7.1/go.mod h1:8WkrPz2fc9jxqZNCJI/76HCieCp4Q8HaLFoCha5qpdg= -github.com/spf13/viper v1.8.1/go.mod h1:o0Pch8wJ9BVSWGQMbra6iw0oQ5oktSIBaujf1rJH9Ns= -github.com/status-im/keycard-go v0.0.0-20190316090335-8537d3370df4/go.mod h1:RZLeN1LMWmRsyYjvAu+I6Dm9QmlDaIIt+Y+4Kd7Tp+Q= -github.com/steakknife/bloomfilter v0.0.0-20180922174646-6819c0d2a570/go.mod h1:8OR4w3TdeIHIh1g6EMY5p0gVNOovcWC+1vpc7naMuAw= -github.com/steakknife/hamming v0.0.0-20180906055917-c99c65617cd3/go.mod h1:hpGUWaI9xL8pRQCTXQgocU38Qw1g0Us7n5PxxTwTCYU= +github.com/spf13/viper v1.10.1/go.mod h1:IGlFPqhNAPKRxohIzWpI5QEy4kuI7tcl5WvR+8qy1rU= github.com/streadway/amqp v0.0.0-20190404075320-75d898a42a94/go.mod h1:AZpEONHx3DKn8O/DFsRAY58/XVQiIPMTMB1SddzLXVw= github.com/streadway/amqp v0.0.0-20190827072141-edfb9018d271/go.mod h1:AZpEONHx3DKn8O/DFsRAY58/XVQiIPMTMB1SddzLXVw= +github.com/streadway/amqp v1.0.0/go.mod h1:AZpEONHx3DKn8O/DFsRAY58/XVQiIPMTMB1SddzLXVw= github.com/streadway/handy v0.0.0-20190108123426-d5acb3125c2a/go.mod h1:qNTQ5P5JnDBl6z3cMAg/SywNDC5ABu5ApDIw6lUbRmI= +github.com/streadway/handy v0.0.0-20200128134331-0f66f006fb2e/go.mod h1:qNTQ5P5JnDBl6z3cMAg/SywNDC5ABu5ApDIw6lUbRmI= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/objx v0.2.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE= github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.1 h1:5TQK59W5E3v0r2duFAb7P95B6hEeOyEnHRa8MjYSMTY= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/subosito/gotenv v1.2.0/go.mod h1:N0PQaV/YGNqwC0u51sEeR/aUtSLEXKX9iv69rRypqCw= github.com/syndtr/gocapability v0.0.0-20200815063812-42c35b437635/go.mod h1:hkRG7XYTFWNJGYcbNJQlaLq0fg1yr4J4t/NcTQtrfww= github.com/syndtr/goleveldb v1.0.1-0.20200815110645-5c35d600f0ca h1:Ld/zXl5t4+D69SiV4JoN7kkfvJdOWlPpfxrzxpLMoUk= github.com/syndtr/goleveldb v1.0.1-0.20200815110645-5c35d600f0ca/go.mod h1:u2MKkTVTVJWe5D1rCvame8WqhBd88EuIwODJZ1VHCPM= github.com/tecbot/gorocksdb v0.0.0-20191217155057-f0fad39f321c/go.mod h1:ahpPrc7HpcfEWDQRZEmnXMzHY03mLDYMCxeDzy46i+8= -github.com/tendermint/btcd v0.1.1/go.mod h1:DC6/m53jtQzr/NFmMNEu0rxf18/ktVoVtMrnDD5pN+U= -github.com/tendermint/crypto v0.0.0-20191022145703-50d29ede1e15/go.mod h1:z4YtwM70uOnk8h0pjJYlj3zdYwi9l03By6iAIF5j/Pk= -github.com/tendermint/go-amino v0.16.0/go.mod h1:TQU0M1i/ImAo+tYpZi73AU3V/dKeCoMC9Sphe2ZwGME= -github.com/tendermint/tendermint v0.34.14 h1:GCXmlS8Bqd2Ix3TQCpwYLUNHe+Y+QyJsm5YE+S/FkPo= github.com/tendermint/tendermint v0.34.14/go.mod h1:FrwVm3TvsVicI9Z7FlucHV6Znfd5KBc/Lpp69cCwtk0= +github.com/tendermint/tendermint v0.34.19 h1:y0P1qI5wSa9IRuhKnTDA6IUcOrLi1hXJuALR+R7HFEk= +github.com/tendermint/tendermint v0.34.19/go.mod h1:R5+wgIwSxMdKQcmOaeudL0Cjkr3HDkhpcdum6VeU3R4= github.com/tendermint/tm-db v0.6.4/go.mod h1:dptYhIpJ2M5kUuenLr+Yyf3zQOv1SgBZcl8/BmWlMBw= +github.com/tendermint/tm-db v0.6.6/go.mod h1:wP8d49A85B7/erz/r4YbKssKw6ylsO/hKtFk7E1aWZI= github.com/tendermint/tm-db v0.6.7 h1:fE00Cbl0jayAoqlExN6oyQJ7fR/ZtoVOmvPJ//+shu8= github.com/tendermint/tm-db v0.6.7/go.mod h1:byQDzFkZV1syXr/ReXS808NxA2xvyuuVgXOJ/088L6I= -github.com/tidwall/gjson v1.6.7/go.mod h1:zeFuBCIqD4sN/gmqBzZ4j7Jd6UcA2Fc56x7QFsv+8fI= -github.com/tidwall/match v1.0.3/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM= -github.com/tidwall/pretty v1.0.2/go.mod h1:XNkn88O1ChpSDQmQeStsy+sBenx6DDtFZJxhVysOjyk= -github.com/tidwall/sjson v1.1.4/go.mod h1:wXpKXu8CtDjKAZ+3DrKY5ROCorDFahq8l0tey/Lx1fg= +github.com/tinylib/msgp v1.1.5/go.mod h1:eQsjooMTnV42mHu917E26IogZ2930nFyBQdofk10Udg= github.com/tmc/grpc-websocket-proxy v0.0.0-20170815181823-89b8d40f7ca8/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U= github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U= +github.com/ttacon/chalk v0.0.0-20160626202418-22c06c80ed31/go.mod h1:onvgF043R+lC5RZ8IT9rBXDaEDnpnw/Cl+HFiw+v/7Q= github.com/tv42/httpunix v0.0.0-20150427012821-b75d8614f926/go.mod h1:9ESjWnEqriFuLhtthL60Sar/7RFoluCcXsuvEwTV5KM= -github.com/tyler-smith/go-bip39 v1.0.1-0.20181017060643-dbb3b84ba2ef/go.mod h1:sJ5fKU0s6JVwZjjcUEX2zFOnvq0ASQ2K9Zr6cf67kNs= -github.com/tyler-smith/go-bip39 v1.0.2/go.mod h1:sJ5fKU0s6JVwZjjcUEX2zFOnvq0ASQ2K9Zr6cf67kNs= -github.com/ugorji/go v1.1.7/go.mod h1:kZn38zHttfInRq0xu/PH0az30d+z6vm202qpg1oXVMw= +github.com/tv42/httpunix v0.0.0-20191220191345-2ba4b9c3382c/go.mod h1:hzIxponao9Kjc7aWznkXaL4U4TWaDSs8zcsY4Ka08nM= +github.com/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGrc= github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0= -github.com/ugorji/go/codec v1.1.7/go.mod h1:Ax+UKWsSmolVDwsd+7N3ZtXu+yMGCf907BLYF3GoBXY= github.com/urfave/cli v1.20.0/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijbERA= github.com/urfave/cli v1.22.1/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0= github.com/vishvananda/netlink v1.1.0/go.mod h1:cTgwzPIzzgDAYoQrMm0EdrjRUBkTqKYppBueQtXaqoE= github.com/vishvananda/netns v0.0.0-20191106174202-0a2b9b5464df/go.mod h1:JP3t17pCcGlemwknint6hfoeCVQrEMVwxRLRjXpq+BU= -github.com/vmihailenco/msgpack/v5 v5.1.4/go.mod h1:C5gboKD0TJPqWDTVTtrQNfRbiBwHZGo8UTqP/9/XvLI= -github.com/vmihailenco/tagparser v0.1.2/go.mod h1:OeAg3pn3UbLjkWt+rN9oFYB6u/cQgqMEUPoW2WPyhdI= -github.com/wsddn/go-ecdh v0.0.0-20161211032359-48726bab9208/go.mod h1:IotVbo4F+mw0EzQ08zFqg7pK3FebNXpaMsRy2RT+Ees= github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU= github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q= -github.com/ybbus/jsonrpc v2.1.2+incompatible/go.mod h1:XJrh1eMSzdIYFbM08flv0wp5G35eRniyeGut1z+LSiE= github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= -github.com/zondax/hid v0.9.0/go.mod h1:l5wttcP0jwtdLjqjMMWFVEE7d1zO0jvSPA9OPZxWpEM= go.etcd.io/bbolt v1.3.2/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU= go.etcd.io/bbolt v1.3.3/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU= go.etcd.io/bbolt v1.3.5/go.mod h1:G5EMThwa9y8QZGBClrRx5EY+Yw9kAhnjy3bSjsnlVTQ= @@ -744,8 +740,12 @@ go.etcd.io/bbolt v1.3.6 h1:/ecaJf0sk1l4l6V4awd65v2C3ILy7MSj+s/x1ADCIMU= go.etcd.io/bbolt v1.3.6/go.mod h1:qXsaaIqmgQH0T+OPdb99Bf+PKfBBQVAdyD6TY9G8XM4= go.etcd.io/etcd v0.0.0-20191023171146-3cf2f69b5738/go.mod h1:dnLIgRNXwCJa5e+c6mIZCrds/GIG4ncV9HhK5PX7jPg= go.etcd.io/etcd/api/v3 v3.5.0/go.mod h1:cbVKeC6lCfl7j/8jBhAK6aIYO9XOjdptoxU/nLQcPvs= +go.etcd.io/etcd/api/v3 v3.5.1/go.mod h1:cbVKeC6lCfl7j/8jBhAK6aIYO9XOjdptoxU/nLQcPvs= go.etcd.io/etcd/client/pkg/v3 v3.5.0/go.mod h1:IJHfcCEKxYu1Os13ZdwCwIUTUVGYTSAM3YSwc9/Ac1g= +go.etcd.io/etcd/client/pkg/v3 v3.5.1/go.mod h1:IJHfcCEKxYu1Os13ZdwCwIUTUVGYTSAM3YSwc9/Ac1g= go.etcd.io/etcd/client/v2 v2.305.0/go.mod h1:h9puh54ZTgAKtEbut2oe9P4L/oqKCVB6xsXlzd7alYQ= +go.etcd.io/etcd/client/v2 v2.305.1/go.mod h1:pMEacxZW7o8pg4CrFE7pquyCJJzZvkvdD2RibOCCCGs= +go.etcd.io/etcd/client/v3 v3.5.0/go.mod h1:AIKXXVX/DQXtfTEqBryiLTUXwON+GuvO6Z7lLS/oTh0= go.opencensus.io v0.20.1/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk= go.opencensus.io v0.20.2/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk= go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU= @@ -760,38 +760,46 @@ go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= go.uber.org/atomic v1.5.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ= go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= +go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= +go.uber.org/goleak v1.1.11-0.20210813005559-691160354723/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ= go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0= go.uber.org/multierr v1.3.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4= go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU= +go.uber.org/multierr v1.7.0/go.mod h1:7EAYxJLBy9rStEaz58O2t4Uvip6FSURkq8/ppBp95ak= go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9Ejo0C68/HhF8uaILCdgjnY+goOA= go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q= go.uber.org/zap v1.13.0/go.mod h1:zwrFLgMcdUuIBviXEYEH1YKNaOBnKXsx2IPda5bBwHM= go.uber.org/zap v1.17.0/go.mod h1:MXVU+bhUf/A7Xi2HNOnopQOrmycQ5Ih87HtOu4q5SSo= +go.uber.org/zap v1.19.1/go.mod h1:j3DNczoxDZroyBnOT1L/Q79cfUMGZxlv/9dzN7SM1rI= golang.org/x/crypto v0.0.0-20170930174604-9419663f5a44/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20181029021203-45a5f77698d3/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= -golang.org/x/crypto v0.0.0-20190426145343-a29dc8fdc734/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190820162420-60c769a6c586/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= -golang.org/x/crypto v0.0.0-20190909091759-094676da4a83/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20190923035154-9ee001bba392/go.mod h1:/lpIB1dKB+9EgE3H3cr1v9wB50oz8l4C4h62xy7jSTY= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20191206172530-e9b2fee46413/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20200115085410-6d4e4cb37c7d/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.0.0-20200323165209-0ec3e9974c59/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20200510223506-06a226fb4e37/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= -golang.org/x/crypto v0.0.0-20200728195943-123391ffb6de/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= -golang.org/x/crypto v0.0.0-20200820211705-5c72a883971a/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20201117144127-c1f2f97bffc9/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I= -golang.org/x/crypto v0.0.0-20210817164053-32db794688a5 h1:HWj/xjIHfjYU5nVXpTM0s39J9CbLn7Cc5a7IC5rwsMQ= +golang.org/x/crypto v0.0.0-20210314154223-e6e6c4f2bb5b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4= +golang.org/x/crypto v0.0.0-20210616213533-5ff15b29337e/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= golang.org/x/crypto v0.0.0-20210817164053-32db794688a5/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +golang.org/x/crypto v0.0.0-20210915214749-c084706c2272 h1:3erb+vDS8lU1sxfDHF4/hhWyaXnhIaO+7RgL4fDZORA= +golang.org/x/crypto v0.0.0-20210915214749-c084706c2272/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +golang.org/x/exp v0.0.0-20180321215751-8460e604b9de/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= +golang.org/x/exp v0.0.0-20180807140117-3d87b88a115f/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= +golang.org/x/exp v0.0.0-20190125153040-c74c464bbbf2/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8= -golang.org/x/exp v0.0.0-20190731235908-ec7cb31e5a56/go.mod h1:JhuoJpWY28nO4Vef9tZUw9qufEGTyX1+7lmHxV5q5G4= golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek= golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY= golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= @@ -799,7 +807,7 @@ golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u0 golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM= golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU= -golang.org/x/exp v0.0.0-20200331195152-e8c3332aa8e5/go.mod h1:4M0jN8W1tt0AVLNr8HDosyJCDCDuyL9N9+3m7wDWgKw= +golang.org/x/image v0.0.0-20180708004352-c73c2afc3b81/go.mod h1:ux5Hcp/YLpHSI86hEcLt0YII63i6oz57MZXIpbrjZUs= golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js= golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= @@ -816,22 +824,20 @@ golang.org/x/lint v0.0.0-20201208152925-83fdc39ff7b5/go.mod h1:3xt1FjdF8hUf6vQPI golang.org/x/lint v0.0.0-20210508222113-6edffad5e616/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE= golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o= -golang.org/x/mobile v0.0.0-20200801112145-973feb4309de/go.mod h1:skQtrUTUwhdJvXM/2KKJzY8pDgNr9I/FOMqDVRPBUS4= golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc= golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY= golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= -golang.org/x/mod v0.1.1-0.20191209134235-331c550502dd/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.5.0/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro= golang.org/x/net v0.0.0-20180719180050-a680a1efc54d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= -golang.org/x/net v0.0.0-20181011144130-49bb7cea24b1/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20181023162649-9b4f9f5ad519/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20181201002055-351d144fa1fc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= @@ -843,6 +849,7 @@ golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190522155817-f3200d17e092/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= @@ -857,7 +864,6 @@ golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLL golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200421231249-e086a090c8fd/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= @@ -867,7 +873,6 @@ golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81R golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= golang.org/x/net v0.0.0-20200813134508-3edf25e44fcc/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= -golang.org/x/net v0.0.0-20200904194848-62affa334b73/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20201031054903-ff519b6c9102/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= @@ -877,10 +882,17 @@ golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4/go.mod h1:RBQZq4jEuRlivfhVLdyRGr576XBO4/greRjx4P4O3yc= golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= +golang.org/x/net v0.0.0-20210410081132-afb366fc7cd1/go.mod h1:9tjilg8BloeKEkVJvy7fQ90B1CfIiPueXVOjqfkSzI8= golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk= +golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20210525063256-abc453219eb5/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.0.0-20210903162142-ad29c8ab022f h1:w6wWR0H+nyVpbSAQbzVEIACVyr/h8l/BEkY6Sokc7Eg= +golang.org/x/net v0.0.0-20210610132358-84b48f89b13b/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20210614182718-04defd469f4e/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20210813160813-60bc85c4be6d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20210903162142-ad29c8ab022f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20210917221730-978cfadd31cf/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20211208012354-db4efeb81f4b h1:MWaHNqZy3KTpuTMAGvv+Kw+ylsEpmyJZizz1dqxnu28= +golang.org/x/net v0.0.0-20211208012354-db4efeb81f4b/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= @@ -892,8 +904,12 @@ golang.org/x/oauth2 v0.0.0-20201208152858-08078c50e5b5/go.mod h1:KelEdhl1UZF7XfJ golang.org/x/oauth2 v0.0.0-20210218202405-ba52d332ba99/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= golang.org/x/oauth2 v0.0.0-20210220000619-9bb904979d93/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= golang.org/x/oauth2 v0.0.0-20210313182246-cd4f82c27b84/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= -golang.org/x/oauth2 v0.0.0-20210402161424-2e8d93401602/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= golang.org/x/oauth2 v0.0.0-20210514164344-f6687ab2804c/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210628180205-a41e5a781914/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210805134026-6f1e6394065a/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210819190943-2bc19b11175f/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20211005180243-6b3c2da341f1/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20211104180415-d3ed0bb246c8/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -916,6 +932,7 @@ golang.org/x/sys v0.0.0-20181122145206-62eef0e2fa9b/go.mod h1:STP8DvDyc/dI5b8T5h golang.org/x/sys v0.0.0-20181205085412-a5c9d58dba9a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190130150945-aca44879d564/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -925,30 +942,32 @@ golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20190606203320-7fc4e5ec1444/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190626221950-04f50cda93cb/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190712062909-fae7ac547cb7/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190826190057-c7b8b68b1456/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190922100055-0a153f010e69/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190924154521-2837fb4f24fe/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191008105621-543471e840be/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191115151921-52ab43148777/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191210023423-ac6580df4449/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191220142924-d4481acd189f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200124204421-9fbb57f87de9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200420163511-1957bb5e6d1f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200501052902-10377860bb8e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -958,7 +977,6 @@ golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200814200057-3d37ad5750ed/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200824131525-c12d262b63d8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200905004654-be1d3432aa8f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200909081042-eff7692f9009/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200923182605-d9f96fdee20d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -971,6 +989,7 @@ golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210220050731-9a76102bfb43/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210303074136-134d130e1a04/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210305230114-8fe3ee5dd75b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210315160823-c6e025ad8005/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -979,12 +998,25 @@ golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210426230700-d19ff857e887/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210514084401-e8d321eab015/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210603125802-9665404d3644/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210903071746-97244b99971b h1:3Dq0eVHn0uaQJmPO+/aYPI/fRMqdrVDbu7MQcku54gg= +golang.org/x/sys v0.0.0-20210806184541-e5e7981a1069/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210816183151-1e6c022a8912/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210823070655-63515b42dcdf/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210903071746-97244b99971b/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210908233432-aa78b53d3365/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210917161153-d61c044b1678/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211007075335-d3039528d8ac/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211124211545-fe61309f8881/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211205182925-97ca703d548d/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211210111614-af8b64212486/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220114195835-da31bd327af9 h1:XfKQ4OlFl8okEOr5UvAqFRVj8pY/4yfcXrddB8qAbU0= +golang.org/x/sys v0.0.0-20220114195835-da31bd327af9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= @@ -994,15 +1026,20 @@ golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.3.6 h1:aRYxNxv6iGQlyVaZmk6ZgYEDa+Jg18DxebPSrd6bg1M= golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk= +golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.0.0-20200416051211-89c76fbcd5d1/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.0.0-20210723032227-1f47c861a9ac/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/tools v0.0.0-20180525024113-a5b4c53f6e8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20190206041539-40960b6deb8e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY= golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= @@ -1015,6 +1052,7 @@ golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgw golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20190907020128-2ca718005c18/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= @@ -1028,7 +1066,6 @@ golang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtn golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20200103221440-774c71fcf114/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200117012304-6edc0a871e69/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20200117161641-43d50277825c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20200122220014-bf1340f18c4a/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= @@ -1043,14 +1080,13 @@ golang.org/x/tools v0.0.0-20200331025713-a30bf2db82d4/go.mod h1:Sl4aGygMT6LrqrWc golang.org/x/tools v0.0.0-20200501065659-ab2804fb9c9d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= golang.org/x/tools v0.0.0-20200512131952-2bc93b1c0c88/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= golang.org/x/tools v0.0.0-20200515010526-7d3b6ebf133d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= -golang.org/x/tools v0.0.0-20200522201501-cb1345f3a375/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= golang.org/x/tools v0.0.0-20200618134242-20370b0cb4b2/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= -golang.org/x/tools v0.0.0-20200717024301-6ddee64345a6/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= golang.org/x/tools v0.0.0-20200729194436-6467de6f59a7/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= golang.org/x/tools v0.0.0-20200904185747-39188db58858/go.mod h1:Cj7w3i3Rnn0Xh82ur9kSqwfTHTeVxaDqrfMjpcNT6bE= +golang.org/x/tools v0.0.0-20201022035929-9cf592e881e9/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.0.0-20201110124207-079ba7bd75cd/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.0.0-20201201161351-ac6f37ff4c2a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.0.0-20201208233053-a543418bbed2/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= @@ -1060,12 +1096,18 @@ golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4f golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0= golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.3/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.4/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +gonum.org/v1/gonum v0.0.0-20180816165407-929014505bf4/go.mod h1:Y+Yx5eoAFn32cQvJDxZx5Dpnq+c3wtXuadVZAcxbbBo= +gonum.org/v1/gonum v0.8.2/go.mod h1:oe/vMfY3deqTw+1EZJhuvEW2iwGF1bW9wwu7XCu0+v0= +gonum.org/v1/netlib v0.0.0-20190313105609-8cb42192e0e0/go.mod h1:wa6Ws7BG/ESfp6dHfk7C6KdzKA7wR7u/rKwOGE66zvw= +gonum.org/v1/plot v0.0.0-20190515093506-e2840ee46a6b/go.mod h1:Wt8AAjI+ypCyYX3nZBvf6cAIx93T+c/OS2HFAYskSZc= google.golang.org/api v0.3.1/go.mod h1:6wY9I6uQWHQ8EM57III9mq/AjF+i8G65rmVagqKMtkk= google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE= google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M= @@ -1088,7 +1130,17 @@ google.golang.org/api v0.36.0/go.mod h1:+z5ficQTmoYpPn8LCUNVpK5I7hwkpjbcgqA7I34q google.golang.org/api v0.40.0/go.mod h1:fYKFpnQN0DsDSKRVRcQSDQNtqWPfM9i+zNPxepjRCQ8= google.golang.org/api v0.41.0/go.mod h1:RkxM5lITDfTzmyKFPt+wGrCJbVfniCr2ool8kTBzRTU= google.golang.org/api v0.43.0/go.mod h1:nQsDGjRXMo4lvh5hP0TKqF244gqhGcr/YSIykhUk/94= -google.golang.org/api v0.44.0/go.mod h1:EBOGZqzyhtvMDoxwS97ctnh0zUmYY6CxqXsc1AvkYD8= +google.golang.org/api v0.47.0/go.mod h1:Wbvgpq1HddcWVtzsVLyfLp8lDg6AA241LmgIL59tHXo= +google.golang.org/api v0.48.0/go.mod h1:71Pr1vy+TAZRPkPs/xlCf5SsU8WjuAWv1Pfjbtukyy4= +google.golang.org/api v0.50.0/go.mod h1:4bNT5pAuq5ji4SRZm+5QIkjny9JAyVD/3gaSihNefaw= +google.golang.org/api v0.51.0/go.mod h1:t4HdrdoNgyN5cbEfm7Lum0lcLDLiise1F8qDKX00sOU= +google.golang.org/api v0.54.0/go.mod h1:7C4bFFOvVDGXjfDTAsgGwDgAxRDeQ4X8NvUedIt6z3k= +google.golang.org/api v0.55.0/go.mod h1:38yMfeP1kfjsl8isn0tliTjIb1rJXcQi4UXlbqivdVE= +google.golang.org/api v0.56.0/go.mod h1:38yMfeP1kfjsl8isn0tliTjIb1rJXcQi4UXlbqivdVE= +google.golang.org/api v0.57.0/go.mod h1:dVPlbZyBo2/OjBpmvNdpn2GRm6rPy75jyU7bmhdrMgI= +google.golang.org/api v0.59.0/go.mod h1:sT2boj7M9YJxZzgeZqXogmhfmRWDtPzT31xkieUbuZU= +google.golang.org/api v0.61.0/go.mod h1:xQRti5UdCmoCEqFxcz93fTl338AVqDgyaDRuOZ3hg9I= +google.golang.org/api v0.63.0/go.mod h1:gs4ij2ffTRXwuzzgJl/56BdwJaA194ijkfn++9tDuPo= google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= google.golang.org/appengine v1.2.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= @@ -1098,7 +1150,6 @@ google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCID google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= -google.golang.org/genproto v0.0.0-20180831171423-11092d34479b/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= @@ -1137,15 +1188,35 @@ google.golang.org/genproto v0.0.0-20201119123407-9b1e624d6bc4/go.mod h1:FWY/as6D google.golang.org/genproto v0.0.0-20201201144952-b05cb90ed32e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20201210142538-e3217bee35cc/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20201214200347-8c77b98c765d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/genproto v0.0.0-20210126160654-44e461bb6506/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20210222152913-aa3ee6e6a81c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20210303154014-9728d6b83eeb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20210310155132-4ce2db91004e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20210319143718-93e7006c17a6/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20210402141018-6c239bbf2bb1/go.mod h1:9lPAdzaEmUacj36I+k7YKbEc5CXzPIeORRgDAUOu28A= +google.golang.org/genproto v0.0.0-20210513213006-bf773b8c8384/go.mod h1:P3QM42oQyzQSnHPnZ/vqoCdDmzH28fzWByN9asMeM8A= google.golang.org/genproto v0.0.0-20210602131652-f16073e35f0c/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0= -google.golang.org/genproto v0.0.0-20210828152312-66f60bf46e71 h1:z+ErRPu0+KS02Td3fOAgdX+lnPDh/VyaABEJPD4JRQs= +google.golang.org/genproto v0.0.0-20210604141403-392c879c8b08/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0= +google.golang.org/genproto v0.0.0-20210608205507-b6d2f5bf0d7d/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0= +google.golang.org/genproto v0.0.0-20210624195500-8bfb893ecb84/go.mod h1:SzzZ/N+nwJDaO1kznhnlzqS8ocJICar6hYhVyhi++24= +google.golang.org/genproto v0.0.0-20210713002101-d411969a0d9a/go.mod h1:AxrInvYm1dci+enl5hChSFPOmmUF1+uAa/UsgNRWd7k= +google.golang.org/genproto v0.0.0-20210716133855-ce7ef5c701ea/go.mod h1:AxrInvYm1dci+enl5hChSFPOmmUF1+uAa/UsgNRWd7k= +google.golang.org/genproto v0.0.0-20210728212813-7823e685a01f/go.mod h1:ob2IJxKrgPT52GcgX759i1sleT07tiKowYBGbczaW48= +google.golang.org/genproto v0.0.0-20210805201207-89edb61ffb67/go.mod h1:ob2IJxKrgPT52GcgX759i1sleT07tiKowYBGbczaW48= +google.golang.org/genproto v0.0.0-20210813162853-db860fec028c/go.mod h1:cFeNkxwySK631ADgubI+/XFU/xp8FD5KIVV4rj8UC5w= +google.golang.org/genproto v0.0.0-20210821163610-241b8fcbd6c8/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= google.golang.org/genproto v0.0.0-20210828152312-66f60bf46e71/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= +google.golang.org/genproto v0.0.0-20210831024726-fe130286e0e2/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= +google.golang.org/genproto v0.0.0-20210903162649-d08c68adba83/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= +google.golang.org/genproto v0.0.0-20210909211513-a8c4777a87af/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= +google.golang.org/genproto v0.0.0-20210917145530-b395a37504d4/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= +google.golang.org/genproto v0.0.0-20210924002016-3dee208752a0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20211008145708-270636b82663/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20211028162531-8db9c33dc351/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20211118181313-81c1377c94b1/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20211206160659-862468c7d6e0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20211208223120-3a66f561d7aa/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20211223182754-3ac035c7e7cb h1:ZrsicilzPCS/Xr8qtBZZLpy4P9TYXAfl49ctG1/5tgw= +google.golang.org/genproto v0.0.0-20211223182754-3ac035c7e7cb/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= google.golang.org/grpc v1.17.0/go.mod h1:6QZJwpn2B+Zp71q/5VxRsJ6NXXVCE5NRUHRo+f3cWCs= google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= google.golang.org/grpc v1.19.1/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= @@ -1165,7 +1236,6 @@ google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3Iji google.golang.org/grpc v1.30.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= google.golang.org/grpc v1.31.1/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= -google.golang.org/grpc v1.32.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= google.golang.org/grpc v1.33.1/go.mod h1:fr5YgcSWrqhRRxogOsw7RzIpsmvOZ6IcH4kBYTpR3n0= google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc= google.golang.org/grpc v1.34.0/go.mod h1:WotjhfgOW/POjDeRt8vscBtXq+2VjORFy659qA51WJ8= @@ -1173,11 +1243,17 @@ google.golang.org/grpc v1.35.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAG google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= google.golang.org/grpc v1.36.1/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= google.golang.org/grpc v1.37.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM= +google.golang.org/grpc v1.37.1/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM= google.golang.org/grpc v1.38.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM= +google.golang.org/grpc v1.39.0/go.mod h1:PImNr+rS9TWYb2O4/emRugxiyHZ5JyHW5F+RPnDzfrE= +google.golang.org/grpc v1.39.1/go.mod h1:PImNr+rS9TWYb2O4/emRugxiyHZ5JyHW5F+RPnDzfrE= google.golang.org/grpc v1.40.0/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34= +google.golang.org/grpc v1.40.1/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34= google.golang.org/grpc v1.42.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU= -google.golang.org/grpc v1.44.0 h1:weqSxi/TMs1SqFRMHCtBgXRs8k3X39QIDEZ0pRcttUg= -google.golang.org/grpc v1.44.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU= +google.golang.org/grpc v1.43.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU= +google.golang.org/grpc v1.45.0 h1:NEpgUqV3Z+ZjkqMsxMg11IaDrXY4RY6CQukSGK0uI1M= +google.golang.org/grpc v1.45.0/go.mod h1:lN7owxKUQEqMfSyQikvvk5tf/6zMPsrK+ONuO11+0rQ= +google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.1.0/go.mod h1:6Kw0yEErY5E/yWrBtf03jp27GLLJujG4z/JK95pnjjw= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= @@ -1188,7 +1264,6 @@ google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2 google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4= google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c= -google.golang.org/protobuf v1.25.1-0.20200805231151-a709e31e5d12/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c= google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= google.golang.org/protobuf v1.27.1 h1:SnqbnDw1V7RiZcXPx5MEeqPv2s79L9i7BJUlG/+RurQ= @@ -1197,19 +1272,17 @@ gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLks gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/cheggaaa/pb.v1 v1.0.25/go.mod h1:V/YB90LKu/1FcN3WVnfiiE5oMCibMjukxqG/qStrOgw= gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI= gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys= gopkg.in/gcfg.v1 v1.2.3/go.mod h1:yesOnuUOFQAhST5vPY4nbZsb/huCgGGXlipJsBn0b3o= gopkg.in/ini.v1 v1.51.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= -gopkg.in/ini.v1 v1.62.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= -gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce/go.mod h1:5AcXVHNjg+BDxry382+8OKon8SEWiKktQR07RKPsv1c= -gopkg.in/olebedev/go-duktape.v3 v3.0.0-20200619000410-60c24ae608a6/go.mod h1:uAJfkITjFhyEEuUfm7bsmCZRbW5WRq8s9EY8HZ6hCns= +gopkg.in/ini.v1 v1.66.2/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo= gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ= gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= -gopkg.in/urfave/cli.v1 v1.20.0/go.mod h1:vuBzUtMdQeixQj8LVd+/98pzhxNGQoyuPBlsXHOQNO0= gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI= gopkg.in/yaml.v2 v2.0.0-20170812160011-eb3733d160e7/go.mod h1:JAlM8MvJe8wmxCU4Bli9HhUf9+ttbYbLASfIpnQbh74= gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= @@ -1233,9 +1306,10 @@ honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWh honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg= honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= -nhooyr.io/websocket v1.8.6/go.mod h1:B70DZP8IakI65RVQ51MsWP/8jndNma26DVA/nFSCgW0= rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8= +rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4= rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0= rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA= sigs.k8s.io/yaml v1.1.0/go.mod h1:UJmg0vDUVViEyp3mgSv9WPwZCDxu4rQW1olrI1uml+o= +sigs.k8s.io/yaml v1.2.0/go.mod h1:yfXDCHCao9+ENCvLSE62v9VSji2MKu5jeNfTrofGhJc= sourcegraph.com/sourcegraph/appdash v0.0.0-20190731080439-ebfcffb1b5c0/go.mod h1:hI742Nqp5OhwiqlzhgfbWU4mW4yO10fP+LoT9WOswdU= From 57f55bee72f69d20f3080ee71a56dfcac7e3a588 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 11 Jul 2022 22:38:48 +0200 Subject: [PATCH 29/37] build(deps): Bump google.golang.org/grpc in /errors (#12520) Bumps [google.golang.org/grpc](https://github.com/grpc/grpc-go) from 1.45.0 to 1.47.0. - [Release notes](https://github.com/grpc/grpc-go/releases) - [Commits](https://github.com/grpc/grpc-go/compare/v1.45.0...v1.47.0) --- updated-dependencies: - dependency-name: google.golang.org/grpc dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- errors/go.mod | 4 ++-- errors/go.sum | 25 ++++++++++++++++--------- 2 files changed, 18 insertions(+), 11 deletions(-) diff --git a/errors/go.mod b/errors/go.mod index 454a925700cd..9103e9e48be2 100644 --- a/errors/go.mod +++ b/errors/go.mod @@ -5,7 +5,7 @@ go 1.18 require ( github.com/pkg/errors v0.9.1 github.com/stretchr/testify v1.8.0 - google.golang.org/grpc v1.45.0 + google.golang.org/grpc v1.47.0 ) require ( @@ -13,6 +13,6 @@ require ( github.com/golang/protobuf v1.5.2 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013 // indirect - google.golang.org/protobuf v1.26.0 // indirect + google.golang.org/protobuf v1.27.1 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/errors/go.sum b/errors/go.sum index 5bc9d35681c2..05c58bf14f79 100644 --- a/errors/go.sum +++ b/errors/go.sum @@ -8,8 +8,8 @@ github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDk github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc= github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= github.com/cncf/udpa/go v0.0.0-20210930031921-04548b0d99d4/go.mod h1:6pvJx4me5XPnfI9Z40ddWsdw2W/uZgQLFXToKeRcDiI= -github.com/cncf/xds/go v0.0.0-20210805033703-aa0b78936158/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= github.com/cncf/xds/go v0.0.0-20210922020428-25de7278fc84/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20211001041855-01bcc9b48dfe/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= @@ -18,7 +18,7 @@ github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymF github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98= github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk= -github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021/go.mod h1:AFq3mo9L8Lqqiid3OhADV3RfLJnjiw63cSpi+fDTRC0= +github.com/envoyproxy/go-control-plane v0.10.2-0.20220325020618-49ff273808a1/go.mod h1:KJwIaB5Mv44NWtYuAOFCVOjcI94vtpEz2JU/D2v6IjE= github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= @@ -42,8 +42,9 @@ github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMyw github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU= github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= +github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= @@ -72,8 +73,9 @@ golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73r golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= -golang.org/x/net v0.0.0-20200822124328-c89045814202 h1:VvcQYSHwXgi7W+TpUR6A9g6Up98WAHf3f/ulnJ62IyA= golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20201021035429-f5854403a974 h1:IX6qOQeG5uLjB/hjjwjedwfjND0hgjPMMyO1RoIXQNI= +golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -83,10 +85,14 @@ golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJ golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd h1:xhmwyvizuTgC2qz7ZlMluP20uW+C3Rm0FD/WLDX8884= golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4 h1:myAQVi0cGEoqQVR5POX+8RR2mrocKqNN1hmeMqhX27k= +golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.3 h1:cokOdA+Jmi5PJGXLlLllQSgYigAEfHXJAERHVMaCc2k= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY= golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= @@ -107,8 +113,8 @@ google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQ google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= google.golang.org/grpc v1.33.1/go.mod h1:fr5YgcSWrqhRRxogOsw7RzIpsmvOZ6IcH4kBYTpR3n0= google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= -google.golang.org/grpc v1.45.0 h1:NEpgUqV3Z+ZjkqMsxMg11IaDrXY4RY6CQukSGK0uI1M= -google.golang.org/grpc v1.45.0/go.mod h1:lN7owxKUQEqMfSyQikvvk5tf/6zMPsrK+ONuO11+0rQ= +google.golang.org/grpc v1.47.0 h1:9n77onPX5F3qfFCqjy9dhn8PbNQsIKeVU04J9G7umt8= +google.golang.org/grpc v1.47.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= @@ -119,8 +125,9 @@ google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2 google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c= google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= -google.golang.org/protobuf v1.26.0 h1:bxAC2xTBsZGibn2RTntX0oH50xLsqy1OxA9tTL3p/lk= google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= +google.golang.org/protobuf v1.27.1 h1:SnqbnDw1V7RiZcXPx5MEeqPv2s79L9i7BJUlG/+RurQ= +google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= From 026d919106f7523c02336a7059499a6752a13700 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 11 Jul 2022 21:08:05 +0000 Subject: [PATCH 30/37] build(deps): Bump github.com/spf13/cobra from 1.4.0 to 1.5.0 in /client/v2 (#12518) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bumps [github.com/spf13/cobra](https://github.com/spf13/cobra) from 1.4.0 to 1.5.0.
Commits

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=github.com/spf13/cobra&package-manager=go_modules&previous-version=1.4.0&new-version=1.5.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores) Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@dependabot rebase`. [//]: # (dependabot-automerge-start) [//]: # (dependabot-automerge-end) ---
Dependabot commands and options
You can trigger Dependabot actions by commenting on this PR: - `@dependabot rebase` will rebase this PR - `@dependabot recreate` will recreate this PR, overwriting any edits that have been made to it - `@dependabot merge` will merge this PR after your CI passes on it - `@dependabot squash and merge` will squash and merge this PR after your CI passes on it - `@dependabot cancel merge` will cancel a previously requested merge and block automerging - `@dependabot reopen` will reopen this PR if it is closed - `@dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually - `@dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
--- client/v2/go.mod | 2 +- client/v2/go.sum | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/client/v2/go.mod b/client/v2/go.mod index 8f239c2ec905..0b95c51f668c 100644 --- a/client/v2/go.mod +++ b/client/v2/go.mod @@ -6,7 +6,7 @@ require ( github.com/cosmos/cosmos-proto v1.0.0-alpha7 github.com/cosmos/cosmos-sdk/api v0.1.0 github.com/iancoleman/strcase v0.2.0 - github.com/spf13/cobra v1.4.0 + github.com/spf13/cobra v1.5.0 github.com/spf13/pflag v1.0.5 google.golang.org/grpc v1.47.0 google.golang.org/protobuf v1.28.0 diff --git a/client/v2/go.sum b/client/v2/go.sum index 99c1a28e9bae..95632ad2457c 100644 --- a/client/v2/go.sum +++ b/client/v2/go.sum @@ -18,7 +18,7 @@ github.com/cosmos/cosmos-proto v1.0.0-alpha7 h1:yqYUOHF2jopwZh4dVQp3xgqwftE5/2hk github.com/cosmos/cosmos-proto v1.0.0-alpha7/go.mod h1:dosO4pSAbJF8zWCzCoTWP7nNsjcvSUBQmniFxDg5daw= github.com/cosmos/cosmos-sdk/api v0.1.0 h1:xfSKM0e9p+EJTMQnf5PbWE6VT8ruxTABIJ64Rd064dE= github.com/cosmos/cosmos-sdk/api v0.1.0/go.mod h1:CupqQBskAOiTXO1XDZ/wrtWzN/wTxUvbQmOqdUhR8wI= -github.com/cpuguy83/go-md2man/v2 v2.0.1/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= +github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= @@ -69,8 +69,8 @@ github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1: github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ= github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= -github.com/spf13/cobra v1.4.0 h1:y+wJpx64xcgO1V+RcnwW0LEHxTKRi2ZDPSBjWnrg88Q= -github.com/spf13/cobra v1.4.0/go.mod h1:Wo4iy3BUC+X2Fybo0PDqwJIv3dNRiZLHQymsfxlB84g= +github.com/spf13/cobra v1.5.0 h1:X+jTBEBqF0bHN+9cSMgmfuvv2VHJ9ezmFNf9Y/XstYU= +github.com/spf13/cobra v1.5.0/go.mod h1:dWXEIy2H428czQCjInthrTRUg7yKbok+2Qi/yBIJoUM= github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4= github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA= github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= From 137c909036fcf11ba551aea25376e81a55f0acce Mon Sep 17 00:00:00 2001 From: Matt Kocubinski Date: Mon, 11 Jul 2022 16:41:50 -0500 Subject: [PATCH 31/37] refactor: remove dependency on simapp from codec (#12530) ## Description Closes: #12528 --- ### Author Checklist *All items are required. Please add a note to the item if the item is not applicable and please add links to any relevant follow up issues.* I have... - [ ] included the correct [type prefix](https://github.com/commitizen/conventional-commit-types/blob/v3.0.0/index.json) in the PR title - [ ] added `!` to the type prefix if API or client breaking change - [ ] targeted the correct branch (see [PR Targeting](https://github.com/cosmos/cosmos-sdk/blob/main/CONTRIBUTING.md#pr-targeting)) - [ ] provided a link to the relevant issue or specification - [ ] followed the guidelines for [building modules](https://github.com/cosmos/cosmos-sdk/blob/main/docs/building-modules) - [ ] included the necessary unit and integration [tests](https://github.com/cosmos/cosmos-sdk/blob/main/CONTRIBUTING.md#testing) - [ ] added a changelog entry to `CHANGELOG.md` - [ ] included comments for [documenting Go code](https://blog.golang.org/godoc) - [ ] updated the relevant documentation or specification - [ ] reviewed "Files changed" and left comments if necessary - [ ] confirmed all CI checks have passed ### Reviewers Checklist *All items are required. Please add a note if the item is not applicable and please add your handle next to the items reviewed if you only reviewed selected items.* I have... - [ ] confirmed the correct [type prefix](https://github.com/commitizen/conventional-commit-types/blob/v3.0.0/index.json) in the PR title - [ ] confirmed `!` in the type prefix if API or client breaking change - [ ] confirmed all author checklist items have been addressed - [ ] reviewed state machine logic - [ ] reviewed API design and naming - [ ] reviewed documentation is accurate - [ ] reviewed tests and test coverage - [ ] manually tested (if applicable) --- codec/amino_codec_test.go | 8 +++++--- codec/any_test.go | 6 +++--- codec/unknownproto/regression_test.go | 4 ++-- 3 files changed, 10 insertions(+), 8 deletions(-) diff --git a/codec/amino_codec_test.go b/codec/amino_codec_test.go index 460ef8ca4184..914d19de6f37 100644 --- a/codec/amino_codec_test.go +++ b/codec/amino_codec_test.go @@ -9,10 +9,12 @@ import ( "github.com/cosmos/cosmos-sdk/codec" "github.com/cosmos/cosmos-sdk/codec/types" - "github.com/cosmos/cosmos-sdk/simapp" "github.com/cosmos/cosmos-sdk/testutil/testdata" + "github.com/cosmos/cosmos-sdk/types/module/testutil" + "github.com/cosmos/cosmos-sdk/x/auth" "github.com/cosmos/cosmos-sdk/x/auth/client/cli" "github.com/cosmos/cosmos-sdk/x/auth/migrations/legacytx" + "github.com/cosmos/cosmos-sdk/x/staking" ) func createTestCodec() *codec.LegacyAmino { @@ -121,7 +123,7 @@ func TestAminoCodecUnpackAnyFails(t *testing.T) { func TestAminoCodecFullDecodeAndEncode(t *testing.T) { // This tx comes from https://github.com/cosmos/cosmos-sdk/issues/8117. txSigned := `{"type":"cosmos-sdk/StdTx","value":{"msg":[{"type":"cosmos-sdk/MsgCreateValidator","value":{"description":{"moniker":"fulltest","identity":"satoshi","website":"example.com","details":"example inc"},"commission":{"rate":"0.500000000000000000","max_rate":"1.000000000000000000","max_change_rate":"0.200000000000000000"},"min_self_delegation":"1000000","delegator_address":"cosmos14pt0q5cwf38zt08uu0n6yrstf3rndzr5057jys","validator_address":"cosmosvaloper14pt0q5cwf38zt08uu0n6yrstf3rndzr52q28gr","pubkey":{"type":"tendermint/PubKeyEd25519","value":"CYrOiM3HtS7uv1B1OAkknZnFYSRpQYSYII8AtMMtev0="},"value":{"denom":"umuon","amount":"700000000"}}}],"fee":{"amount":[{"denom":"umuon","amount":"6000"}],"gas":"160000"},"signatures":[{"pub_key":{"type":"tendermint/PubKeySecp256k1","value":"AwAOXeWgNf1FjMaayrSnrOOKz+Fivr6DiI/i0x0sZCHw"},"signature":"RcnfS/u2yl7uIShTrSUlDWvsXo2p2dYu6WJC8VDVHMBLEQZWc8bsINSCjOnlsIVkUNNe1q/WCA9n3Gy1+0zhYA=="}],"memo":"","timeout_height":"0"}}` - legacyCdc := simapp.MakeTestEncodingConfig().Amino + legacyCdc := testutil.MakeTestEncodingConfig(staking.AppModuleBasic{}, auth.AppModuleBasic{}).Amino var tx legacytx.StdTx err := legacyCdc.UnmarshalJSON([]byte(txSigned), &tx) require.NoError(t, err) @@ -129,7 +131,7 @@ func TestAminoCodecFullDecodeAndEncode(t *testing.T) { // Marshalling/unmarshalling the tx should work. marshaledTx, err := legacyCdc.MarshalJSON(tx) require.NoError(t, err) - require.Equal(t, string(marshaledTx), txSigned) + require.Equal(t, txSigned, string(marshaledTx)) // Marshalling/unmarshalling the tx wrapped in a struct should work. txRequest := &cli.BroadcastReq{ diff --git a/codec/any_test.go b/codec/any_test.go index 8b4b96a7fb5b..dfa5276a1d62 100644 --- a/codec/any_test.go +++ b/codec/any_test.go @@ -10,8 +10,8 @@ import ( codectypes "github.com/cosmos/cosmos-sdk/codec/types" "github.com/cosmos/cosmos-sdk/crypto/keys/ed25519" cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types" - "github.com/cosmos/cosmos-sdk/simapp" "github.com/cosmos/cosmos-sdk/testutil/testdata" + "github.com/cosmos/cosmos-sdk/types/module/testutil" ) func NewTestInterfaceRegistry() types.InterfaceRegistry { @@ -60,7 +60,7 @@ func TestMarshalAny(t *testing.T) { func TestMarshalProtoPubKey(t *testing.T) { require := require.New(t) - ccfg := simapp.MakeTestEncodingConfig() + ccfg := testutil.MakeTestEncodingConfig() privKey := ed25519.GenPrivKey() pk := privKey.PubKey() @@ -100,7 +100,7 @@ func TestMarshalProtoPubKey(t *testing.T) { // helper functions func TestMarshalProtoInterfacePubKey(t *testing.T) { require := require.New(t) - ccfg := simapp.MakeTestEncodingConfig() + ccfg := testutil.MakeTestEncodingConfig() privKey := ed25519.GenPrivKey() pk := privKey.PubKey() diff --git a/codec/unknownproto/regression_test.go b/codec/unknownproto/regression_test.go index 24c4056fbd39..3473e6481c14 100644 --- a/codec/unknownproto/regression_test.go +++ b/codec/unknownproto/regression_test.go @@ -7,14 +7,14 @@ import ( "github.com/stretchr/testify/require" - "github.com/cosmos/cosmos-sdk/simapp" + "github.com/cosmos/cosmos-sdk/types/module/testutil" ) // Issue #7739: Catch parse errors resulting from unexpected EOF in // protowire.ConsumeFieldValue. Discovered from fuzzing. func TestBadBytesPassedIntoDecoder(t *testing.T) { data, _ := hex.DecodeString("0A9F010A9C200A2D2F6962632E636F72652E636F6E6E656374696F6E2E76312E4D7367436F6E6E656374696F584F75656E496E6974126B0A0D6962637A65726F636C69656E74120B6962637A65726F636F6E6E1A1C0A0C6962636F6E65636C69656E74120A6962636F6E65636F6E6E00002205312E302E302A283235454635364341373935313335453430393336384536444238313130463232413442453035433212080A0612040A0208011A40143342993E25DA936CDDC7BE3D8F603CA6E9661518D536D0C482E18A0154AA096E438A6B9BCADFCFC2F0D689DCCAF55B96399D67A8361B70F5DA13091E2F929") - cfg := simapp.MakeTestEncodingConfig() + cfg := testutil.MakeTestEncodingConfig() decoder := cfg.TxConfig.TxDecoder() tx, err := decoder(data) From b555840fb0f140d4b288bb8f65ed8eee9aa414fa Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 11 Jul 2022 21:59:32 +0000 Subject: [PATCH 32/37] build(deps): Bump gotest.tools/v3 from 3.1.0 to 3.3.0 in /client/v2 (#12516) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bumps [gotest.tools/v3](https://github.com/gotestyourself/gotest.tools) from 3.1.0 to 3.3.0.
Release notes

Sourced from gotest.tools/v3's releases.

v3.3.0

What's Changed

Full Changelog: https://github.com/gotestyourself/gotest.tools/compare/v3.2.0...v3.3.0

v3.2.0

What's Changed

Full Changelog: https://github.com/gotestyourself/gotest.tools/compare/v3.1.0...v3.2.0

Commits
  • 4de0c9f Merge pull request #237 from dnephin/golden-vars
  • 82e8930 assert: tests for golden variables
  • a0e2cd3 assert: first draft of inline golden variables
  • 3abbc52 refactor: prepare for other uses of the ast.File
  • 2686168 Move update flag to internal/source package
  • 814f970 Merge pull request #238 from dnephin/golden-flag
  • 7efa051 Update docs about the update flag
  • 7dc1daf Merge pull request #236 from gotestyourself/update-readme
  • 13888f7 Merge pull request #235 from dnephin/golden-flag
  • 6e64c83 golden: accept -update for updating files
  • Additional commits viewable in compare view

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=gotest.tools/v3&package-manager=go_modules&previous-version=3.1.0&new-version=3.3.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores) Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@dependabot rebase`. [//]: # (dependabot-automerge-start) [//]: # (dependabot-automerge-end) ---
Dependabot commands and options
You can trigger Dependabot actions by commenting on this PR: - `@dependabot rebase` will rebase this PR - `@dependabot recreate` will recreate this PR, overwriting any edits that have been made to it - `@dependabot merge` will merge this PR after your CI passes on it - `@dependabot squash and merge` will squash and merge this PR after your CI passes on it - `@dependabot cancel merge` will cancel a previously requested merge and block automerging - `@dependabot reopen` will reopen this PR if it is closed - `@dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually - `@dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
--- client/v2/go.mod | 3 +-- client/v2/go.sum | 6 ++---- 2 files changed, 3 insertions(+), 6 deletions(-) diff --git a/client/v2/go.mod b/client/v2/go.mod index 0b95c51f668c..36046a0f2b6a 100644 --- a/client/v2/go.mod +++ b/client/v2/go.mod @@ -10,7 +10,7 @@ require ( github.com/spf13/pflag v1.0.5 google.golang.org/grpc v1.47.0 google.golang.org/protobuf v1.28.0 - gotest.tools/v3 v3.1.0 + gotest.tools/v3 v3.3.0 ) require ( @@ -18,7 +18,6 @@ require ( github.com/golang/protobuf v1.5.2 // indirect github.com/google/go-cmp v0.5.6 // indirect github.com/inconshreveable/mousetrap v1.0.0 // indirect - github.com/pkg/errors v0.9.1 // indirect golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4 // indirect golang.org/x/sys v0.0.0-20210510120138-977fb7262007 // indirect golang.org/x/text v0.3.5 // indirect diff --git a/client/v2/go.sum b/client/v2/go.sum index 95632ad2457c..6c2fb1e99987 100644 --- a/client/v2/go.sum +++ b/client/v2/go.sum @@ -62,8 +62,6 @@ github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NH github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8= github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= -github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= -github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ= @@ -174,8 +172,8 @@ gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gotest.tools/v3 v3.1.0 h1:rVV8Tcg/8jHUkPUorwjaMTtemIMVXfIPKiOqnhEhakk= -gotest.tools/v3 v3.1.0/go.mod h1:fHy7eyTmJFO5bQbUsEGQ1v4m2J3Jz9eWL54TP2/ZuYQ= +gotest.tools/v3 v3.3.0 h1:MfDY1b1/0xN1CyMlQDac0ziEy9zJQd9CXBRRDHw2jJo= +gotest.tools/v3 v3.3.0/go.mod h1:Mcr9QNxkg0uMvy/YElmo4SpXgJKWgQvYrT7Kw5RzJ1A= honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= pgregory.net/rapid v0.4.7/go.mod h1:UYpPVyjFHzYBGHIxLFoupi8vwk6rXNzRY9OMvVxFIOU= From 8090177144c0085c5aa0c01992ceea3729c2d03e Mon Sep 17 00:00:00 2001 From: Marko Date: Tue, 12 Jul 2022 06:37:49 +0200 Subject: [PATCH 33/37] chore: Fix legacy simapp compilation (#12531) --- .github/workflows/legacy-test.yml | 4 --- .github/workflows/test.yml | 2 ++ Makefile | 4 +++ simapp/app_legacy.go | 41 ++++++++++++++----------------- 4 files changed, 24 insertions(+), 27 deletions(-) diff --git a/.github/workflows/legacy-test.yml b/.github/workflows/legacy-test.yml index 2a779c342ae0..51800984def5 100644 --- a/.github/workflows/legacy-test.yml +++ b/.github/workflows/legacy-test.yml @@ -45,9 +45,7 @@ jobs: with: go-version: 1.18 - name: Run submodule tests and create test coverage profile. - # GIT_DIFF is passed to the scripts run: bash scripts/module-tests.sh - if: env.GIT_DIFF - uses: actions/upload-artifact@v3 with: name: "${{ github.sha }}-go-submodules-coverage" @@ -97,11 +95,9 @@ jobs: - uses: actions/download-artifact@v3 with: name: "${{ github.sha }}-${{ matrix.part }}" - if: env.GIT_DIFF - name: test & coverage report creation run: | cat pkgs.txt.part.${{ matrix.part }} | xargs go test -mod=readonly -timeout 30m -coverprofile=${{ matrix.part }}profile.out -covermode=atomic -tags='legacy_simapp norace ledger test_ledger_mock' - if: env.GIT_DIFF - uses: actions/upload-artifact@v3 with: name: "${{ github.sha }}-${{ matrix.part }}-coverage" diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 2c0b448770c1..2364cc880915 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -47,6 +47,8 @@ jobs: key: ${{ runner.os }}-go-build-${{ hashFiles('**/go.sum') }} - name: Build run: GOARCH=${{ matrix.go-arch }} LEDGER_ENABLED=false make build + - name: Build Legacy + run: GOARCH=${{ matrix.go-arch }} LEDGER_ENABLED=false COSMOS_BUILD_OPTIONS=legacy make build - name: Build cosmovisor run: GOARCH=${{ matrix.go-arch }} LEDGER_ENABLED=false make cosmovisor diff --git a/Makefile b/Makefile index 8ac5ec4e148d..c386f74b96c1 100644 --- a/Makefile +++ b/Makefile @@ -51,6 +51,10 @@ ifeq (secp,$(findstring secp,$(COSMOS_BUILD_OPTIONS))) build_tags += libsecp256k1_sdk endif +ifeq (legacy,$(findstring legacy,$(COSMOS_BUILD_OPTIONS))) + build_tags += legacy_simapp +endif + whitespace := whitespace += $(whitespace) comma := , diff --git a/simapp/app_legacy.go b/simapp/app_legacy.go index 4443d13d2c35..37db22adcaed 100644 --- a/simapp/app_legacy.go +++ b/simapp/app_legacy.go @@ -255,25 +255,20 @@ func NewSimApp( app.CapabilityKeeper.Seal() // add keepers - app.AccountKeeper = authkeeper.NewAccountKeeper( - appCodec, keys[authtypes.StoreKey], app.GetSubspace(authtypes.ModuleName), authtypes.ProtoBaseAccount, maccPerms, sdk.Bech32MainPrefix, - ) + app.AccountKeeper = authkeeper.NewAccountKeeper(appCodec, keys[authtypes.StoreKey], authtypes.ProtoBaseAccount, maccPerms, sdk.Bech32MainPrefix, authtypes.NewModuleAddress(govtypes.ModuleName).String()) + app.BankKeeper = bankkeeper.NewBaseKeeper( appCodec, keys[banktypes.StoreKey], app.AccountKeeper, app.GetSubspace(banktypes.ModuleName), app.ModuleAccountAddrs(), ) app.StakingKeeper = stakingkeeper.NewKeeper( appCodec, keys[stakingtypes.StoreKey], app.AccountKeeper, app.BankKeeper, app.GetSubspace(stakingtypes.ModuleName), ) - app.MintKeeper = mintkeeper.NewKeeper( - appCodec, keys[minttypes.StoreKey], app.GetSubspace(minttypes.ModuleName), app.StakingKeeper, - app.AccountKeeper, app.BankKeeper, authtypes.FeeCollectorName, - ) - app.DistrKeeper = distrkeeper.NewKeeper( - appCodec, keys[distrtypes.StoreKey], app.GetSubspace(distrtypes.ModuleName), app.AccountKeeper, app.BankKeeper, - app.StakingKeeper, authtypes.FeeCollectorName, - ) + app.MintKeeper = mintkeeper.NewKeeper(appCodec, keys[minttypes.StoreKey], app.StakingKeeper, app.AccountKeeper, app.BankKeeper, authtypes.FeeCollectorName, authtypes.NewModuleAddress(govtypes.ModuleName).String()) + + app.DistrKeeper = distrkeeper.NewKeeper(appCodec, keys[distrtypes.StoreKey], app.AccountKeeper, app.BankKeeper, app.StakingKeeper, authtypes.FeeCollectorName, authtypes.NewModuleAddress(govtypes.ModuleName).String()) + app.SlashingKeeper = slashingkeeper.NewKeeper( - appCodec, keys[slashingtypes.StoreKey], app.StakingKeeper, app.GetSubspace(slashingtypes.ModuleName), + appCodec, legacyAmino, keys[slashingtypes.StoreKey], app.StakingKeeper, authtypes.NewModuleAddress(govtypes.ModuleName).String(), ) invCheckPeriod := cast.ToUint(appOpts.Get(server.FlagInvCheckPeriod)) @@ -314,7 +309,7 @@ func NewSimApp( */ govKeeper := govkeeper.NewKeeper( appCodec, keys[govtypes.StoreKey], app.GetSubspace(govtypes.ModuleName), app.AccountKeeper, app.BankKeeper, - app.StakingKeeper, govRouter, app.MsgServiceRouter(), govConfig, + app.StakingKeeper, app.MsgServiceRouter(), govConfig, ) app.GovKeeper = *govKeeper.SetHooks( @@ -357,16 +352,16 @@ func NewSimApp( app.AccountKeeper, app.StakingKeeper, app.BaseApp.DeliverTx, encodingConfig.TxConfig, ), - auth.NewAppModule(appCodec, app.AccountKeeper, authsims.RandomGenesisAccounts), + auth.NewAppModule(appCodec, app.AccountKeeper, authsims.RandomGenesisAccounts, app.GetSubspace(authtypes.ModuleName)), vesting.NewAppModule(app.AccountKeeper, app.BankKeeper), bank.NewAppModule(appCodec, app.BankKeeper, app.AccountKeeper), capability.NewAppModule(appCodec, *app.CapabilityKeeper, false), crisis.NewAppModule(app.CrisisKeeper, skipGenesisInvariants), feegrantmodule.NewAppModule(appCodec, app.AccountKeeper, app.BankKeeper, app.FeeGrantKeeper, app.interfaceRegistry), - gov.NewAppModule(appCodec, app.GovKeeper, app.AccountKeeper, app.BankKeeper), - mint.NewAppModule(appCodec, app.MintKeeper, app.AccountKeeper, nil), - slashing.NewAppModule(appCodec, app.SlashingKeeper, app.AccountKeeper, app.BankKeeper, app.StakingKeeper), - distr.NewAppModule(appCodec, app.DistrKeeper, app.AccountKeeper, app.BankKeeper, app.StakingKeeper), + gov.NewAppModule(appCodec, &app.GovKeeper, app.AccountKeeper, app.BankKeeper), + mint.NewAppModule(appCodec, app.MintKeeper, app.AccountKeeper, nil, app.GetSubspace(minttypes.ModuleName)), + slashing.NewAppModule(appCodec, app.SlashingKeeper, app.AccountKeeper, app.BankKeeper, app.StakingKeeper, app.GetSubspace(slashingtypes.ModuleName)), + distr.NewAppModule(appCodec, app.DistrKeeper, app.AccountKeeper, app.BankKeeper, app.StakingKeeper, app.GetSubspace(distrtypes.ModuleName)), staking.NewAppModule(appCodec, app.StakingKeeper, app.AccountKeeper, app.BankKeeper), upgrade.NewAppModule(app.UpgradeKeeper), evidence.NewAppModule(app.EvidenceKeeper), @@ -427,15 +422,15 @@ func NewSimApp( // NOTE: this is not required apps that don't use the simulator for fuzz testing // transactions app.sm = module.NewSimulationManager( - auth.NewAppModule(appCodec, app.AccountKeeper, authsims.RandomGenesisAccounts), + auth.NewAppModule(appCodec, app.AccountKeeper, authsims.RandomGenesisAccounts, app.GetSubspace(authtypes.ModuleName)), bank.NewAppModule(appCodec, app.BankKeeper, app.AccountKeeper), capability.NewAppModule(appCodec, *app.CapabilityKeeper, false), feegrantmodule.NewAppModule(appCodec, app.AccountKeeper, app.BankKeeper, app.FeeGrantKeeper, app.interfaceRegistry), - gov.NewAppModule(appCodec, app.GovKeeper, app.AccountKeeper, app.BankKeeper), - mint.NewAppModule(appCodec, app.MintKeeper, app.AccountKeeper, nil), + gov.NewAppModule(appCodec, &app.GovKeeper, app.AccountKeeper, app.BankKeeper), + mint.NewAppModule(appCodec, app.MintKeeper, app.AccountKeeper, nil, app.GetSubspace(minttypes.ModuleName)), staking.NewAppModule(appCodec, app.StakingKeeper, app.AccountKeeper, app.BankKeeper), - distr.NewAppModule(appCodec, app.DistrKeeper, app.AccountKeeper, app.BankKeeper, app.StakingKeeper), - slashing.NewAppModule(appCodec, app.SlashingKeeper, app.AccountKeeper, app.BankKeeper, app.StakingKeeper), + distr.NewAppModule(appCodec, app.DistrKeeper, app.AccountKeeper, app.BankKeeper, app.StakingKeeper, app.GetSubspace(distrtypes.ModuleName)), + slashing.NewAppModule(appCodec, app.SlashingKeeper, app.AccountKeeper, app.BankKeeper, app.StakingKeeper, app.GetSubspace(slashingtypes.ModuleName)), params.NewAppModule(app.ParamsKeeper), evidence.NewAppModule(app.EvidenceKeeper), authzmodule.NewAppModule(appCodec, app.AuthzKeeper, app.AccountKeeper, app.BankKeeper, app.interfaceRegistry), From 7c1d743499a07ebcf50717258a9f23e1fb68f888 Mon Sep 17 00:00:00 2001 From: atheeshp <59333759+atheeshp@users.noreply.github.com> Date: Tue, 12 Jul 2022 11:45:50 +0530 Subject: [PATCH 34/37] feat: remove x/params dependency in x/crisis (#12491) ## Description Closes: #12445 --- ### Author Checklist *All items are required. Please add a note to the item if the item is not applicable and please add links to any relevant follow up issues.* I have... - [ ] included the correct [type prefix](https://github.com/commitizen/conventional-commit-types/blob/v3.0.0/index.json) in the PR title - [ ] added `!` to the type prefix if API or client breaking change - [ ] targeted the correct branch (see [PR Targeting](https://github.com/cosmos/cosmos-sdk/blob/main/CONTRIBUTING.md#pr-targeting)) - [ ] provided a link to the relevant issue or specification - [ ] followed the guidelines for [building modules](https://github.com/cosmos/cosmos-sdk/blob/main/docs/building-modules) - [ ] included the necessary unit and integration [tests](https://github.com/cosmos/cosmos-sdk/blob/main/CONTRIBUTING.md#testing) - [ ] added a changelog entry to `CHANGELOG.md` - [ ] included comments for [documenting Go code](https://blog.golang.org/godoc) - [ ] updated the relevant documentation or specification - [ ] reviewed "Files changed" and left comments if necessary - [ ] confirmed all CI checks have passed ### Reviewers Checklist *All items are required. Please add a note if the item is not applicable and please add your handle next to the items reviewed if you only reviewed selected items.* I have... - [ ] confirmed the correct [type prefix](https://github.com/commitizen/conventional-commit-types/blob/v3.0.0/index.json) in the PR title - [ ] confirmed `!` in the type prefix if API or client breaking change - [ ] confirmed all author checklist items have been addressed - [ ] reviewed state machine logic - [ ] reviewed API design and naming - [ ] reviewed documentation is accurate - [ ] reviewed tests and test coverage - [ ] manually tested (if applicable) --- CHANGELOG.md | 2 + api/cosmos/crisis/v1beta1/tx.pulsar.go | 1047 ++++++++++++++++- api/cosmos/crisis/v1beta1/tx_grpc.pb.go | 44 + proto/cosmos/crisis/v1beta1/tx.proto | 26 + x/crisis/exported/exported.go | 19 + x/crisis/keeper/genesis.go | 4 +- x/crisis/keeper/keeper.go | 26 +- x/crisis/keeper/migrator.go | 28 + x/crisis/keeper/msg_server.go | 15 + x/crisis/keeper/msg_server_test.go | 94 ++ x/crisis/keeper/params.go | 29 +- x/crisis/keeper/params_test.go | 52 + x/crisis/migrations/v046/migrate.go | 41 + x/crisis/migrations/v046/migrate_test.go | 44 + x/crisis/module.go | 27 +- x/crisis/types/codec.go | 2 + x/crisis/types/keys.go | 6 + .../types/{params.go => legacy_params.go} | 0 x/crisis/types/msgs.go | 43 +- x/crisis/types/tx.pb.go | 450 ++++++- 20 files changed, 1923 insertions(+), 76 deletions(-) create mode 100644 x/crisis/exported/exported.go create mode 100644 x/crisis/keeper/migrator.go create mode 100644 x/crisis/keeper/msg_server_test.go create mode 100644 x/crisis/keeper/params_test.go create mode 100644 x/crisis/migrations/v046/migrate.go create mode 100644 x/crisis/migrations/v046/migrate_test.go rename x/crisis/types/{params.go => legacy_params.go} (100%) diff --git a/CHANGELOG.md b/CHANGELOG.md index 06e9ee46bfec..2de9127aaeaa 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -60,6 +60,7 @@ Ref: https://keepachangelog.com/en/1.0.0/ * (x/slashing) [#12399](https://github.com/cosmos/cosmos-sdk/pull/12399) Migrate `x/slashing` to self-managed parameters and deprecate its usage of `x/params`. * (x/mint) [#12363](https://github.com/cosmos/cosmos-sdk/pull/12363) Migrate `x/mint` to self-managed parameters and deprecate it's usage of `x/params`. * (x/distribution) [#12434](https://github.com/cosmos/cosmos-sdk/pull/12434) Migrate `x/distribution` to self-managed parameters and deprecate it's usage of `x/params`. +* (x/crisis) [#12445](https://github.com/cosmos/cosmos-sdk/pull/12445) Migrate `x/crisis` to self-managed parameters and deprecate it's usage of `x/params`. ### API Breaking Changes @@ -73,6 +74,7 @@ Ref: https://keepachangelog.com/en/1.0.0/ * (x/staking) [#12102](https://github.com/cosmos/cosmos-sdk/pull/12102) Staking keeper now is passed by reference instead of copy. Keeper's SetHooks no longer returns keeper. It updates the keeper in place instead. * (linting) [#12141](https://github.com/cosmos/cosmos-sdk/pull/12141) Fix usability related linting for database. This means removing the infix Prefix from `prefix.NewPrefixWriter` and such so that it is `prefix.NewWriter` and making `db.DBConnection` and such into `db.Connection` * (x/distribution) [#12434](https://github.com/cosmos/cosmos-sdk/pull/12434) `x/distribution` module `SetParams` keeper method definition is now updated to return `error`. +* (x/crisis) [#12445](https://github.com/cosmos/cosmos-sdk/pull/12445) `x/crisis` module `SetConstantFee` keeper method definition is now updated to return `error`. ### Bug Fixes diff --git a/api/cosmos/crisis/v1beta1/tx.pulsar.go b/api/cosmos/crisis/v1beta1/tx.pulsar.go index 13a5f6f51adb..1b6acca498ef 100644 --- a/api/cosmos/crisis/v1beta1/tx.pulsar.go +++ b/api/cosmos/crisis/v1beta1/tx.pulsar.go @@ -2,6 +2,7 @@ package crisisv1beta1 import ( + v1beta1 "cosmossdk.io/api/cosmos/base/v1beta1" _ "cosmossdk.io/api/cosmos/msg/v1" fmt "fmt" _ "github.com/cosmos/cosmos-proto" @@ -919,6 +920,861 @@ func (x *fastReflection_MsgVerifyInvariantResponse) ProtoMethods() *protoiface.M } } +var ( + md_MsgUpdateParams protoreflect.MessageDescriptor + fd_MsgUpdateParams_authority protoreflect.FieldDescriptor + fd_MsgUpdateParams_constant_fee protoreflect.FieldDescriptor +) + +func init() { + file_cosmos_crisis_v1beta1_tx_proto_init() + md_MsgUpdateParams = File_cosmos_crisis_v1beta1_tx_proto.Messages().ByName("MsgUpdateParams") + fd_MsgUpdateParams_authority = md_MsgUpdateParams.Fields().ByName("authority") + fd_MsgUpdateParams_constant_fee = md_MsgUpdateParams.Fields().ByName("constant_fee") +} + +var _ protoreflect.Message = (*fastReflection_MsgUpdateParams)(nil) + +type fastReflection_MsgUpdateParams MsgUpdateParams + +func (x *MsgUpdateParams) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgUpdateParams)(x) +} + +func (x *MsgUpdateParams) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_crisis_v1beta1_tx_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_MsgUpdateParams_messageType fastReflection_MsgUpdateParams_messageType +var _ protoreflect.MessageType = fastReflection_MsgUpdateParams_messageType{} + +type fastReflection_MsgUpdateParams_messageType struct{} + +func (x fastReflection_MsgUpdateParams_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgUpdateParams)(nil) +} +func (x fastReflection_MsgUpdateParams_messageType) New() protoreflect.Message { + return new(fastReflection_MsgUpdateParams) +} +func (x fastReflection_MsgUpdateParams_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgUpdateParams +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgUpdateParams) Descriptor() protoreflect.MessageDescriptor { + return md_MsgUpdateParams +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_MsgUpdateParams) Type() protoreflect.MessageType { + return _fastReflection_MsgUpdateParams_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgUpdateParams) New() protoreflect.Message { + return new(fastReflection_MsgUpdateParams) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgUpdateParams) Interface() protoreflect.ProtoMessage { + return (*MsgUpdateParams)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_MsgUpdateParams) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Authority != "" { + value := protoreflect.ValueOfString(x.Authority) + if !f(fd_MsgUpdateParams_authority, value) { + return + } + } + if x.ConstantFee != nil { + value := protoreflect.ValueOfMessage(x.ConstantFee.ProtoReflect()) + if !f(fd_MsgUpdateParams_constant_fee, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_MsgUpdateParams) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "cosmos.crisis.v1beta1.MsgUpdateParams.authority": + return x.Authority != "" + case "cosmos.crisis.v1beta1.MsgUpdateParams.constant_fee": + return x.ConstantFee != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.crisis.v1beta1.MsgUpdateParams")) + } + panic(fmt.Errorf("message cosmos.crisis.v1beta1.MsgUpdateParams does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_MsgUpdateParams) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "cosmos.crisis.v1beta1.MsgUpdateParams.authority": + x.Authority = "" + case "cosmos.crisis.v1beta1.MsgUpdateParams.constant_fee": + x.ConstantFee = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.crisis.v1beta1.MsgUpdateParams")) + } + panic(fmt.Errorf("message cosmos.crisis.v1beta1.MsgUpdateParams does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_MsgUpdateParams) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "cosmos.crisis.v1beta1.MsgUpdateParams.authority": + value := x.Authority + return protoreflect.ValueOfString(value) + case "cosmos.crisis.v1beta1.MsgUpdateParams.constant_fee": + value := x.ConstantFee + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.crisis.v1beta1.MsgUpdateParams")) + } + panic(fmt.Errorf("message cosmos.crisis.v1beta1.MsgUpdateParams does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_MsgUpdateParams) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "cosmos.crisis.v1beta1.MsgUpdateParams.authority": + x.Authority = value.Interface().(string) + case "cosmos.crisis.v1beta1.MsgUpdateParams.constant_fee": + x.ConstantFee = value.Message().Interface().(*v1beta1.Coin) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.crisis.v1beta1.MsgUpdateParams")) + } + panic(fmt.Errorf("message cosmos.crisis.v1beta1.MsgUpdateParams does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_MsgUpdateParams) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.crisis.v1beta1.MsgUpdateParams.constant_fee": + if x.ConstantFee == nil { + x.ConstantFee = new(v1beta1.Coin) + } + return protoreflect.ValueOfMessage(x.ConstantFee.ProtoReflect()) + case "cosmos.crisis.v1beta1.MsgUpdateParams.authority": + panic(fmt.Errorf("field authority of message cosmos.crisis.v1beta1.MsgUpdateParams is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.crisis.v1beta1.MsgUpdateParams")) + } + panic(fmt.Errorf("message cosmos.crisis.v1beta1.MsgUpdateParams does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_MsgUpdateParams) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.crisis.v1beta1.MsgUpdateParams.authority": + return protoreflect.ValueOfString("") + case "cosmos.crisis.v1beta1.MsgUpdateParams.constant_fee": + m := new(v1beta1.Coin) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.crisis.v1beta1.MsgUpdateParams")) + } + panic(fmt.Errorf("message cosmos.crisis.v1beta1.MsgUpdateParams does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_MsgUpdateParams) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.crisis.v1beta1.MsgUpdateParams", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_MsgUpdateParams) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_MsgUpdateParams) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_MsgUpdateParams) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_MsgUpdateParams) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgUpdateParams) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + l = len(x.Authority) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.ConstantFee != nil { + l = options.Size(x.ConstantFee) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*MsgUpdateParams) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if x.ConstantFee != nil { + encoded, err := options.Marshal(x.ConstantFee) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x12 + } + if len(x.Authority) > 0 { + i -= len(x.Authority) + copy(dAtA[i:], x.Authority) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Authority))) + i-- + dAtA[i] = 0xa + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*MsgUpdateParams) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUpdateParams: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUpdateParams: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Authority = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ConstantFee", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.ConstantFee == nil { + x.ConstantFee = &v1beta1.Coin{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ConstantFee); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_MsgUpdateParamsResponse protoreflect.MessageDescriptor +) + +func init() { + file_cosmos_crisis_v1beta1_tx_proto_init() + md_MsgUpdateParamsResponse = File_cosmos_crisis_v1beta1_tx_proto.Messages().ByName("MsgUpdateParamsResponse") +} + +var _ protoreflect.Message = (*fastReflection_MsgUpdateParamsResponse)(nil) + +type fastReflection_MsgUpdateParamsResponse MsgUpdateParamsResponse + +func (x *MsgUpdateParamsResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgUpdateParamsResponse)(x) +} + +func (x *MsgUpdateParamsResponse) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_crisis_v1beta1_tx_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_MsgUpdateParamsResponse_messageType fastReflection_MsgUpdateParamsResponse_messageType +var _ protoreflect.MessageType = fastReflection_MsgUpdateParamsResponse_messageType{} + +type fastReflection_MsgUpdateParamsResponse_messageType struct{} + +func (x fastReflection_MsgUpdateParamsResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgUpdateParamsResponse)(nil) +} +func (x fastReflection_MsgUpdateParamsResponse_messageType) New() protoreflect.Message { + return new(fastReflection_MsgUpdateParamsResponse) +} +func (x fastReflection_MsgUpdateParamsResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgUpdateParamsResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgUpdateParamsResponse) Descriptor() protoreflect.MessageDescriptor { + return md_MsgUpdateParamsResponse +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_MsgUpdateParamsResponse) Type() protoreflect.MessageType { + return _fastReflection_MsgUpdateParamsResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgUpdateParamsResponse) New() protoreflect.Message { + return new(fastReflection_MsgUpdateParamsResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgUpdateParamsResponse) Interface() protoreflect.ProtoMessage { + return (*MsgUpdateParamsResponse)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_MsgUpdateParamsResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_MsgUpdateParamsResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.crisis.v1beta1.MsgUpdateParamsResponse")) + } + panic(fmt.Errorf("message cosmos.crisis.v1beta1.MsgUpdateParamsResponse does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_MsgUpdateParamsResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.crisis.v1beta1.MsgUpdateParamsResponse")) + } + panic(fmt.Errorf("message cosmos.crisis.v1beta1.MsgUpdateParamsResponse does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_MsgUpdateParamsResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.crisis.v1beta1.MsgUpdateParamsResponse")) + } + panic(fmt.Errorf("message cosmos.crisis.v1beta1.MsgUpdateParamsResponse does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_MsgUpdateParamsResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.crisis.v1beta1.MsgUpdateParamsResponse")) + } + panic(fmt.Errorf("message cosmos.crisis.v1beta1.MsgUpdateParamsResponse does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_MsgUpdateParamsResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.crisis.v1beta1.MsgUpdateParamsResponse")) + } + panic(fmt.Errorf("message cosmos.crisis.v1beta1.MsgUpdateParamsResponse does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_MsgUpdateParamsResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.crisis.v1beta1.MsgUpdateParamsResponse")) + } + panic(fmt.Errorf("message cosmos.crisis.v1beta1.MsgUpdateParamsResponse does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_MsgUpdateParamsResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.crisis.v1beta1.MsgUpdateParamsResponse", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_MsgUpdateParamsResponse) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_MsgUpdateParamsResponse) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_MsgUpdateParamsResponse) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_MsgUpdateParamsResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgUpdateParamsResponse) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*MsgUpdateParamsResponse) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*MsgUpdateParamsResponse) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUpdateParamsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUpdateParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.27.0 @@ -1011,6 +1867,84 @@ func (*MsgVerifyInvariantResponse) Descriptor() ([]byte, []int) { return file_cosmos_crisis_v1beta1_tx_proto_rawDescGZIP(), []int{1} } +// MsgUpdateParams is the Msg/UpdateParams request type. +// +// Since: cosmos-sdk 0.47 +type MsgUpdateParams struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // authority is the address of the governance account. + Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"` + // constant_fee defines the x/crisis parameter. + ConstantFee *v1beta1.Coin `protobuf:"bytes,2,opt,name=constant_fee,json=constantFee,proto3" json:"constant_fee,omitempty"` +} + +func (x *MsgUpdateParams) Reset() { + *x = MsgUpdateParams{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_crisis_v1beta1_tx_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgUpdateParams) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgUpdateParams) ProtoMessage() {} + +// Deprecated: Use MsgUpdateParams.ProtoReflect.Descriptor instead. +func (*MsgUpdateParams) Descriptor() ([]byte, []int) { + return file_cosmos_crisis_v1beta1_tx_proto_rawDescGZIP(), []int{2} +} + +func (x *MsgUpdateParams) GetAuthority() string { + if x != nil { + return x.Authority + } + return "" +} + +func (x *MsgUpdateParams) GetConstantFee() *v1beta1.Coin { + if x != nil { + return x.ConstantFee + } + return nil +} + +// MsgUpdateParamsResponse defines the response structure for executing a +// MsgUpdateParams message. +// +// Since: cosmos-sdk 0.47 +type MsgUpdateParamsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *MsgUpdateParamsResponse) Reset() { + *x = MsgUpdateParamsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_crisis_v1beta1_tx_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgUpdateParamsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgUpdateParamsResponse) ProtoMessage() {} + +// Deprecated: Use MsgUpdateParamsResponse.ProtoReflect.Descriptor instead. +func (*MsgUpdateParamsResponse) Descriptor() ([]byte, []int) { + return file_cosmos_crisis_v1beta1_tx_proto_rawDescGZIP(), []int{3} +} + var File_cosmos_crisis_v1beta1_tx_proto protoreflect.FileDescriptor var file_cosmos_crisis_v1beta1_tx_proto_rawDesc = []byte{ @@ -1022,6 +1956,8 @@ var file_cosmos_crisis_v1beta1_tx_proto_rawDesc = []byte{ 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x17, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x6d, 0x73, 0x67, 0x2f, 0x76, 0x31, 0x2f, 0x6d, 0x73, 0x67, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x1a, 0x1e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x62, 0x61, 0x73, 0x65, 0x2f, 0x76, + 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x63, 0x6f, 0x69, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xb8, 0x01, 0x0a, 0x12, 0x4d, 0x73, 0x67, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x49, 0x6e, 0x76, 0x61, 0x72, 0x69, 0x61, 0x6e, 0x74, 0x12, 0x30, 0x0a, 0x06, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f, @@ -1035,28 +1971,47 @@ var file_cosmos_crisis_v1beta1_tx_proto_rawDesc = []byte{ 0x6e, 0x74, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x3a, 0x13, 0x88, 0xa0, 0x1f, 0x00, 0xe8, 0xa0, 0x1f, 0x00, 0x82, 0xe7, 0xb0, 0x2a, 0x06, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x22, 0x1c, 0x0a, 0x1a, 0x4d, 0x73, 0x67, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x49, 0x6e, 0x76, 0x61, 0x72, 0x69, 0x61, - 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x32, 0x76, 0x0a, 0x03, 0x4d, 0x73, - 0x67, 0x12, 0x6f, 0x0a, 0x0f, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x49, 0x6e, 0x76, 0x61, 0x72, - 0x69, 0x61, 0x6e, 0x74, 0x12, 0x29, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x63, 0x72, - 0x69, 0x73, 0x69, 0x73, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4d, 0x73, 0x67, - 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x49, 0x6e, 0x76, 0x61, 0x72, 0x69, 0x61, 0x6e, 0x74, 0x1a, - 0x31, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x63, 0x72, 0x69, 0x73, 0x69, 0x73, 0x2e, - 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x56, 0x65, 0x72, 0x69, 0x66, - 0x79, 0x49, 0x6e, 0x76, 0x61, 0x72, 0x69, 0x61, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x42, 0xd0, 0x01, 0x0a, 0x19, 0x63, 0x6f, 0x6d, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, - 0x73, 0x2e, 0x63, 0x72, 0x69, 0x73, 0x69, 0x73, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, - 0x42, 0x07, 0x54, 0x78, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x34, 0x63, 0x6f, 0x73, - 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x63, 0x6f, - 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x63, 0x72, 0x69, 0x73, 0x69, 0x73, 0x2f, 0x76, 0x31, 0x62, 0x65, - 0x74, 0x61, 0x31, 0x3b, 0x63, 0x72, 0x69, 0x73, 0x69, 0x73, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, - 0x31, 0xa2, 0x02, 0x03, 0x43, 0x43, 0x58, 0xaa, 0x02, 0x15, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, - 0x2e, 0x43, 0x72, 0x69, 0x73, 0x69, 0x73, 0x2e, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0xca, - 0x02, 0x15, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x43, 0x72, 0x69, 0x73, 0x69, 0x73, 0x5c, - 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0xe2, 0x02, 0x21, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, - 0x5c, 0x43, 0x72, 0x69, 0x73, 0x69, 0x73, 0x5c, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x5c, - 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x17, 0x43, 0x6f, - 0x73, 0x6d, 0x6f, 0x73, 0x3a, 0x3a, 0x43, 0x72, 0x69, 0x73, 0x69, 0x73, 0x3a, 0x3a, 0x56, 0x31, - 0x62, 0x65, 0x74, 0x61, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x9d, 0x01, 0x0a, 0x0f, 0x4d, + 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x36, + 0x0a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, + 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x09, 0x61, 0x75, 0x74, + 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x42, 0x0a, 0x0c, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x61, + 0x6e, 0x74, 0x5f, 0x66, 0x65, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x63, + 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, + 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x69, 0x6e, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x0b, 0x63, + 0x6f, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x46, 0x65, 0x65, 0x3a, 0x0e, 0x82, 0xe7, 0xb0, 0x2a, + 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x22, 0x19, 0x0a, 0x17, 0x4d, 0x73, + 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x32, 0xde, 0x01, 0x0a, 0x03, 0x4d, 0x73, 0x67, 0x12, 0x6f, 0x0a, + 0x0f, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x49, 0x6e, 0x76, 0x61, 0x72, 0x69, 0x61, 0x6e, 0x74, + 0x12, 0x29, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x63, 0x72, 0x69, 0x73, 0x69, 0x73, + 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x56, 0x65, 0x72, 0x69, + 0x66, 0x79, 0x49, 0x6e, 0x76, 0x61, 0x72, 0x69, 0x61, 0x6e, 0x74, 0x1a, 0x31, 0x2e, 0x63, 0x6f, + 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x63, 0x72, 0x69, 0x73, 0x69, 0x73, 0x2e, 0x76, 0x31, 0x62, 0x65, + 0x74, 0x61, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x49, 0x6e, 0x76, + 0x61, 0x72, 0x69, 0x61, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x66, + 0x0a, 0x0c, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x12, 0x26, + 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x63, 0x72, 0x69, 0x73, 0x69, 0x73, 0x2e, 0x76, + 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, + 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x1a, 0x2e, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, + 0x63, 0x72, 0x69, 0x73, 0x69, 0x73, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4d, + 0x73, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0xd0, 0x01, 0x0a, 0x19, 0x63, 0x6f, 0x6d, 0x2e, 0x63, + 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x63, 0x72, 0x69, 0x73, 0x69, 0x73, 0x2e, 0x76, 0x31, 0x62, + 0x65, 0x74, 0x61, 0x31, 0x42, 0x07, 0x54, 0x78, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, + 0x34, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x61, 0x70, + 0x69, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x63, 0x72, 0x69, 0x73, 0x69, 0x73, 0x2f, + 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x3b, 0x63, 0x72, 0x69, 0x73, 0x69, 0x73, 0x76, 0x31, + 0x62, 0x65, 0x74, 0x61, 0x31, 0xa2, 0x02, 0x03, 0x43, 0x43, 0x58, 0xaa, 0x02, 0x15, 0x43, 0x6f, + 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x43, 0x72, 0x69, 0x73, 0x69, 0x73, 0x2e, 0x56, 0x31, 0x62, 0x65, + 0x74, 0x61, 0x31, 0xca, 0x02, 0x15, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x43, 0x72, 0x69, + 0x73, 0x69, 0x73, 0x5c, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0xe2, 0x02, 0x21, 0x43, 0x6f, + 0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x43, 0x72, 0x69, 0x73, 0x69, 0x73, 0x5c, 0x56, 0x31, 0x62, 0x65, + 0x74, 0x61, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, + 0x02, 0x17, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x3a, 0x3a, 0x43, 0x72, 0x69, 0x73, 0x69, 0x73, + 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x33, } var ( @@ -1071,19 +2026,25 @@ func file_cosmos_crisis_v1beta1_tx_proto_rawDescGZIP() []byte { return file_cosmos_crisis_v1beta1_tx_proto_rawDescData } -var file_cosmos_crisis_v1beta1_tx_proto_msgTypes = make([]protoimpl.MessageInfo, 2) +var file_cosmos_crisis_v1beta1_tx_proto_msgTypes = make([]protoimpl.MessageInfo, 4) var file_cosmos_crisis_v1beta1_tx_proto_goTypes = []interface{}{ (*MsgVerifyInvariant)(nil), // 0: cosmos.crisis.v1beta1.MsgVerifyInvariant (*MsgVerifyInvariantResponse)(nil), // 1: cosmos.crisis.v1beta1.MsgVerifyInvariantResponse + (*MsgUpdateParams)(nil), // 2: cosmos.crisis.v1beta1.MsgUpdateParams + (*MsgUpdateParamsResponse)(nil), // 3: cosmos.crisis.v1beta1.MsgUpdateParamsResponse + (*v1beta1.Coin)(nil), // 4: cosmos.base.v1beta1.Coin } var file_cosmos_crisis_v1beta1_tx_proto_depIdxs = []int32{ - 0, // 0: cosmos.crisis.v1beta1.Msg.VerifyInvariant:input_type -> cosmos.crisis.v1beta1.MsgVerifyInvariant - 1, // 1: cosmos.crisis.v1beta1.Msg.VerifyInvariant:output_type -> cosmos.crisis.v1beta1.MsgVerifyInvariantResponse - 1, // [1:2] is the sub-list for method output_type - 0, // [0:1] is the sub-list for method input_type - 0, // [0:0] is the sub-list for extension type_name - 0, // [0:0] is the sub-list for extension extendee - 0, // [0:0] is the sub-list for field type_name + 4, // 0: cosmos.crisis.v1beta1.MsgUpdateParams.constant_fee:type_name -> cosmos.base.v1beta1.Coin + 0, // 1: cosmos.crisis.v1beta1.Msg.VerifyInvariant:input_type -> cosmos.crisis.v1beta1.MsgVerifyInvariant + 2, // 2: cosmos.crisis.v1beta1.Msg.UpdateParams:input_type -> cosmos.crisis.v1beta1.MsgUpdateParams + 1, // 3: cosmos.crisis.v1beta1.Msg.VerifyInvariant:output_type -> cosmos.crisis.v1beta1.MsgVerifyInvariantResponse + 3, // 4: cosmos.crisis.v1beta1.Msg.UpdateParams:output_type -> cosmos.crisis.v1beta1.MsgUpdateParamsResponse + 3, // [3:5] is the sub-list for method output_type + 1, // [1:3] is the sub-list for method input_type + 1, // [1:1] is the sub-list for extension type_name + 1, // [1:1] is the sub-list for extension extendee + 0, // [0:1] is the sub-list for field type_name } func init() { file_cosmos_crisis_v1beta1_tx_proto_init() } @@ -1116,6 +2077,30 @@ func file_cosmos_crisis_v1beta1_tx_proto_init() { return nil } } + file_cosmos_crisis_v1beta1_tx_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgUpdateParams); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cosmos_crisis_v1beta1_tx_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgUpdateParamsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } } type x struct{} out := protoimpl.TypeBuilder{ @@ -1123,7 +2108,7 @@ func file_cosmos_crisis_v1beta1_tx_proto_init() { GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: file_cosmos_crisis_v1beta1_tx_proto_rawDesc, NumEnums: 0, - NumMessages: 2, + NumMessages: 4, NumExtensions: 0, NumServices: 1, }, diff --git a/api/cosmos/crisis/v1beta1/tx_grpc.pb.go b/api/cosmos/crisis/v1beta1/tx_grpc.pb.go index bd137cf2bb2f..bf5162aa0590 100644 --- a/api/cosmos/crisis/v1beta1/tx_grpc.pb.go +++ b/api/cosmos/crisis/v1beta1/tx_grpc.pb.go @@ -24,6 +24,11 @@ const _ = grpc.SupportPackageIsVersion7 type MsgClient interface { // VerifyInvariant defines a method to verify a particular invariance. VerifyInvariant(ctx context.Context, in *MsgVerifyInvariant, opts ...grpc.CallOption) (*MsgVerifyInvariantResponse, error) + // UpdateParams defines a governance operation for updating the x/crisis module + // parameters. The authority is defined in the keeper. + // + // Since: cosmos-sdk 0.47 + UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) } type msgClient struct { @@ -43,12 +48,26 @@ func (c *msgClient) VerifyInvariant(ctx context.Context, in *MsgVerifyInvariant, return out, nil } +func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) { + out := new(MsgUpdateParamsResponse) + err := c.cc.Invoke(ctx, "/cosmos.crisis.v1beta1.Msg/UpdateParams", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // MsgServer is the server API for Msg service. // All implementations must embed UnimplementedMsgServer // for forward compatibility type MsgServer interface { // VerifyInvariant defines a method to verify a particular invariance. VerifyInvariant(context.Context, *MsgVerifyInvariant) (*MsgVerifyInvariantResponse, error) + // UpdateParams defines a governance operation for updating the x/crisis module + // parameters. The authority is defined in the keeper. + // + // Since: cosmos-sdk 0.47 + UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error) mustEmbedUnimplementedMsgServer() } @@ -59,6 +78,9 @@ type UnimplementedMsgServer struct { func (UnimplementedMsgServer) VerifyInvariant(context.Context, *MsgVerifyInvariant) (*MsgVerifyInvariantResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method VerifyInvariant not implemented") } +func (UnimplementedMsgServer) UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateParams not implemented") +} func (UnimplementedMsgServer) mustEmbedUnimplementedMsgServer() {} // UnsafeMsgServer may be embedded to opt out of forward compatibility for this service. @@ -90,6 +112,24 @@ func _Msg_VerifyInvariant_Handler(srv interface{}, ctx context.Context, dec func return interceptor(ctx, in, info, handler) } +func _Msg_UpdateParams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgUpdateParams) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).UpdateParams(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmos.crisis.v1beta1.Msg/UpdateParams", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).UpdateParams(ctx, req.(*MsgUpdateParams)) + } + return interceptor(ctx, in, info, handler) +} + // Msg_ServiceDesc is the grpc.ServiceDesc for Msg service. // It's only intended for direct use with grpc.RegisterService, // and not to be introspected or modified (even as a copy) @@ -101,6 +141,10 @@ var Msg_ServiceDesc = grpc.ServiceDesc{ MethodName: "VerifyInvariant", Handler: _Msg_VerifyInvariant_Handler, }, + { + MethodName: "UpdateParams", + Handler: _Msg_UpdateParams_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "cosmos/crisis/v1beta1/tx.proto", diff --git a/proto/cosmos/crisis/v1beta1/tx.proto b/proto/cosmos/crisis/v1beta1/tx.proto index fea9059f6f03..b87f10951b7d 100644 --- a/proto/cosmos/crisis/v1beta1/tx.proto +++ b/proto/cosmos/crisis/v1beta1/tx.proto @@ -6,11 +6,18 @@ option go_package = "github.com/cosmos/cosmos-sdk/x/crisis/types"; import "gogoproto/gogo.proto"; import "cosmos_proto/cosmos.proto"; import "cosmos/msg/v1/msg.proto"; +import "cosmos/base/v1beta1/coin.proto"; // Msg defines the bank Msg service. service Msg { // VerifyInvariant defines a method to verify a particular invariance. rpc VerifyInvariant(MsgVerifyInvariant) returns (MsgVerifyInvariantResponse); + + // UpdateParams defines a governance operation for updating the x/crisis module + // parameters. The authority is defined in the keeper. + // + // Since: cosmos-sdk 0.47 + rpc UpdateParams(MsgUpdateParams) returns (MsgUpdateParamsResponse); } // MsgVerifyInvariant represents a message to verify a particular invariance. @@ -27,3 +34,22 @@ message MsgVerifyInvariant { // MsgVerifyInvariantResponse defines the Msg/VerifyInvariant response type. message MsgVerifyInvariantResponse {} + +// MsgUpdateParams is the Msg/UpdateParams request type. +// +// Since: cosmos-sdk 0.47 +message MsgUpdateParams { + option (cosmos.msg.v1.signer) = "authority"; + + // authority is the address of the governance account. + string authority = 1 [(cosmos_proto.scalar) = "cosmos.AddressString"]; + + // constant_fee defines the x/crisis parameter. + cosmos.base.v1beta1.Coin constant_fee = 2 [(gogoproto.nullable) = false]; +} + +// MsgUpdateParamsResponse defines the response structure for executing a +// MsgUpdateParams message. +// +// Since: cosmos-sdk 0.47 +message MsgUpdateParamsResponse {} diff --git a/x/crisis/exported/exported.go b/x/crisis/exported/exported.go new file mode 100644 index 000000000000..4360786511eb --- /dev/null +++ b/x/crisis/exported/exported.go @@ -0,0 +1,19 @@ +package exported + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" +) + +type ( + ParamSet = paramtypes.ParamSet + + // Subspace defines an interface that implements the legacy x/params Subspace + // type. + // + // NOTE: This is used solely for migration of x/params managed parameters. + Subspace interface { + // GetParamSet(ctx sdk.Context, ps ParamSet) + Get(ctx sdk.Context, key []byte, ptr interface{}) + } +) diff --git a/x/crisis/keeper/genesis.go b/x/crisis/keeper/genesis.go index f8553bbbd55b..c0249989a443 100644 --- a/x/crisis/keeper/genesis.go +++ b/x/crisis/keeper/genesis.go @@ -7,7 +7,9 @@ import ( // new crisis genesis func (k *Keeper) InitGenesis(ctx sdk.Context, data *types.GenesisState) { - k.SetConstantFee(ctx, data.ConstantFee) + if err := k.SetConstantFee(ctx, data.ConstantFee); err != nil { + panic(err) + } } // ExportGenesis returns a GenesisState for a given context and keeper. diff --git a/x/crisis/keeper/keeper.go b/x/crisis/keeper/keeper.go index b1442ff5d465..c806e917134f 100644 --- a/x/crisis/keeper/keeper.go +++ b/x/crisis/keeper/keeper.go @@ -6,38 +6,46 @@ import ( "github.com/tendermint/tendermint/libs/log" + "github.com/cosmos/cosmos-sdk/codec" + storetypes "github.com/cosmos/cosmos-sdk/store/types" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/crisis/types" - paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" ) // Keeper - crisis keeper type Keeper struct { routes []types.InvarRoute - paramSpace paramtypes.Subspace invCheckPeriod uint + storeKey storetypes.StoreKey + cdc codec.BinaryCodec + + // the address capable of executing a MsgUpdateParams message. Typically, this + // should be the x/gov module account. + authority string supplyKeeper types.SupplyKeeper feeCollectorName string // name of the FeeCollector ModuleAccount } +func (k *Keeper) GetAuthority() string { + return k.authority +} + // NewKeeper creates a new Keeper object func NewKeeper( - paramSpace paramtypes.Subspace, invCheckPeriod uint, supplyKeeper types.SupplyKeeper, - feeCollectorName string, + cdc codec.BinaryCodec, storeKey storetypes.StoreKey, invCheckPeriod uint, + supplyKeeper types.SupplyKeeper, feeCollectorName string, authority string, ) *Keeper { - // set KeyTable if it has not already been set - if !paramSpace.HasKeyTable() { - paramSpace = paramSpace.WithKeyTable(types.ParamKeyTable()) - } return &Keeper{ + storeKey: storeKey, + cdc: cdc, routes: make([]types.InvarRoute, 0), - paramSpace: paramSpace, invCheckPeriod: invCheckPeriod, supplyKeeper: supplyKeeper, feeCollectorName: feeCollectorName, + authority: authority, } } diff --git a/x/crisis/keeper/migrator.go b/x/crisis/keeper/migrator.go new file mode 100644 index 000000000000..6094e0dbb3d8 --- /dev/null +++ b/x/crisis/keeper/migrator.go @@ -0,0 +1,28 @@ +package keeper + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/crisis/exported" + v046 "github.com/cosmos/cosmos-sdk/x/crisis/migrations/v046" +) + +// Migrator is a struct for handling in-place state migrations. +type Migrator struct { + keeper *Keeper + legacySubspace exported.Subspace +} + +func NewMigrator(k *Keeper, ss exported.Subspace) Migrator { + return Migrator{ + keeper: k, + legacySubspace: ss, + } +} + +// Migrate1to2 migrates the x/mint module state from the consensus version 1 to +// version 2. Specifically, it takes the parameters that are currently stored +// and managed by the x/params modules and stores them directly into the x/mint +// module state. +func (m Migrator) Migrate1to2(ctx sdk.Context) error { + return v046.MigrateStore(ctx, m.keeper.storeKey, m.legacySubspace, m.keeper.cdc) +} diff --git a/x/crisis/keeper/msg_server.go b/x/crisis/keeper/msg_server.go index 7e02a370e907..e0bede26214c 100644 --- a/x/crisis/keeper/msg_server.go +++ b/x/crisis/keeper/msg_server.go @@ -4,7 +4,9 @@ import ( "context" sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/crisis/types" + govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" ) var _ types.MsgServer = &Keeper{} @@ -64,3 +66,16 @@ func (k *Keeper) VerifyInvariant(goCtx context.Context, msg *types.MsgVerifyInva return &types.MsgVerifyInvariantResponse{}, nil } + +func (k *Keeper) UpdateParams(goCtx context.Context, req *types.MsgUpdateParams) (*types.MsgUpdateParamsResponse, error) { + if k.authority != req.Authority { + return nil, errors.Wrapf(govtypes.ErrInvalidSigner, "invalid authority; expected %s, got %s", k.authority, req.Authority) + } + + ctx := sdk.UnwrapSDKContext(goCtx) + if err := k.SetConstantFee(ctx, req.ConstantFee); err != nil { + return nil, err + } + + return &types.MsgUpdateParamsResponse{}, nil +} diff --git a/x/crisis/keeper/msg_server_test.go b/x/crisis/keeper/msg_server_test.go new file mode 100644 index 000000000000..6d4ba8e546f1 --- /dev/null +++ b/x/crisis/keeper/msg_server_test.go @@ -0,0 +1,94 @@ +package keeper_test + +import ( + "testing" + + "github.com/cosmos/cosmos-sdk/simapp" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/x/crisis/keeper" + "github.com/cosmos/cosmos-sdk/x/crisis/types" + "github.com/stretchr/testify/suite" + abci "github.com/tendermint/tendermint/abci/types" + tmproto "github.com/tendermint/tendermint/proto/tendermint/types" +) + +type KeeperTestSuite struct { + suite.Suite + + ctx sdk.Context + keeper *keeper.Keeper +} + +func (s *KeeperTestSuite) SetupTest() { + app := simapp.Setup(s.T(), false) + app.Commit() + app.BeginBlock(abci.RequestBeginBlock{Header: tmproto.Header{Height: app.LastBlockHeight() + 1}}) + ctx := app.NewContext(true, tmproto.Header{}) + + s.ctx = ctx + s.keeper = app.CrisisKeeper +} + +func (s *KeeperTestSuite) TestMsgUpdateParams() { + // default params + constantFee := sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(1000)) + + testCases := []struct { + name string + input *types.MsgUpdateParams + expErr bool + expErrMsg string + }{ + { + name: "invalid authority", + input: &types.MsgUpdateParams{ + Authority: "invalid", + ConstantFee: constantFee, + }, + expErr: true, + expErrMsg: "invalid authority", + }, + { + name: "invalid constant fee", + input: &types.MsgUpdateParams{ + Authority: s.keeper.GetAuthority(), + ConstantFee: sdk.Coin{}, + }, + expErr: true, + }, + { + name: "negative constant fee", + input: &types.MsgUpdateParams{ + Authority: s.keeper.GetAuthority(), + ConstantFee: sdk.Coin{Denom: sdk.DefaultBondDenom, Amount: sdk.NewInt(-1000)}, + }, + expErr: true, + }, + { + name: "all good", + input: &types.MsgUpdateParams{ + Authority: s.keeper.GetAuthority(), + ConstantFee: constantFee, + }, + expErr: false, + }, + } + + for _, tc := range testCases { + tc := tc + s.Run(tc.name, func() { + _, err := s.keeper.UpdateParams(s.ctx, tc.input) + + if tc.expErr { + s.Require().Error(err) + s.Require().Contains(err.Error(), tc.expErrMsg) + } else { + s.Require().NoError(err) + } + }) + } +} + +func TestKeeperTestSuite(t *testing.T) { + suite.Run(t, new(KeeperTestSuite)) +} diff --git a/x/crisis/keeper/params.go b/x/crisis/keeper/params.go index 82a42a30896e..e24eb58bd46a 100644 --- a/x/crisis/keeper/params.go +++ b/x/crisis/keeper/params.go @@ -2,16 +2,33 @@ package keeper import ( sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/crisis/types" ) -// GetConstantFee get's the constant fee from the paramSpace +// GetConstantFee get's the constant fee from the store func (k *Keeper) GetConstantFee(ctx sdk.Context) (constantFee sdk.Coin) { - k.paramSpace.Get(ctx, types.ParamStoreKeyConstantFee, &constantFee) - return + store := ctx.KVStore(k.storeKey) + bz := store.Get(types.ConstantFeeKey) + if bz == nil { + return constantFee + } + k.cdc.MustUnmarshal(bz, &constantFee) + return constantFee } -// GetConstantFee set's the constant fee in the paramSpace -func (k *Keeper) SetConstantFee(ctx sdk.Context, constantFee sdk.Coin) { - k.paramSpace.Set(ctx, types.ParamStoreKeyConstantFee, constantFee) +// GetConstantFee set's the constant fee in the store +func (k *Keeper) SetConstantFee(ctx sdk.Context, constantFee sdk.Coin) error { + if !constantFee.IsValid() || constantFee.IsNegative() { + return errors.Wrapf(errors.ErrInvalidCoins, "negative or invalid constant fee: %s", constantFee) + } + + store := ctx.KVStore(k.storeKey) + bz, err := k.cdc.Marshal(&constantFee) + if err != nil { + return err + } + + store.Set(types.ConstantFeeKey, bz) + return nil } diff --git a/x/crisis/keeper/params_test.go b/x/crisis/keeper/params_test.go new file mode 100644 index 000000000000..b5c65e5e5806 --- /dev/null +++ b/x/crisis/keeper/params_test.go @@ -0,0 +1,52 @@ +package keeper_test + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" +) + +func (s *KeeperTestSuite) TestParams() { + // default params + constantFee := sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(1000)) + + testCases := []struct { + name string + constantFee sdk.Coin + expErr bool + expErrMsg string + }{ + { + name: "invalid constant fee", + constantFee: sdk.Coin{}, + expErr: true, + }, + { + name: "negative constant fee", + constantFee: sdk.Coin{Denom: sdk.DefaultBondDenom, Amount: sdk.NewInt(-1000)}, + expErr: true, + }, + { + name: "all good", + constantFee: constantFee, + expErr: false, + }, + } + + for _, tc := range testCases { + tc := tc + s.Run(tc.name, func() { + expected := s.keeper.GetConstantFee(s.ctx) + err := s.keeper.SetConstantFee(s.ctx, tc.constantFee) + + if tc.expErr { + s.Require().Error(err) + s.Require().Contains(err.Error(), tc.expErrMsg) + } else { + expected = tc.constantFee + s.Require().NoError(err) + } + + params := s.keeper.GetConstantFee(s.ctx) + s.Require().Equal(expected, params) + }) + } +} diff --git a/x/crisis/migrations/v046/migrate.go b/x/crisis/migrations/v046/migrate.go new file mode 100644 index 000000000000..333b4be89403 --- /dev/null +++ b/x/crisis/migrations/v046/migrate.go @@ -0,0 +1,41 @@ +package v046 + +import ( + "github.com/cosmos/cosmos-sdk/codec" + storetypes "github.com/cosmos/cosmos-sdk/store/types" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/errors" + "github.com/cosmos/cosmos-sdk/x/crisis/exported" +) + +const ( + ModuleName = "crisis" +) + +var ( + ConstantFee = []byte("ConstantFee") + ConstantFeeKey = []byte{0x01} +) + +// MigrateStore migrates the x/crisis module state from the consensus version 1 to +// version 2. Specifically, it takes the `ConstantFee` parameter that is currently stored +// and managed by the x/params module and stores it directly into the x/crisis +// module state. +func MigrateStore(ctx sdk.Context, storeKey storetypes.StoreKey, legacySubspace exported.Subspace, cdc codec.BinaryCodec) error { + store := ctx.KVStore(storeKey) + var currConstantFee sdk.Coin + legacySubspace.Get(ctx, ConstantFee, &currConstantFee) + + if !currConstantFee.IsValid() { + return errors.ErrInvalidCoins.Wrap("constant fee") + } + + bz, err := cdc.Marshal(&currConstantFee) + if err != nil { + return err + } + + store.Set(ConstantFeeKey, bz) + + return nil +} diff --git a/x/crisis/migrations/v046/migrate_test.go b/x/crisis/migrations/v046/migrate_test.go new file mode 100644 index 000000000000..ae283a688f85 --- /dev/null +++ b/x/crisis/migrations/v046/migrate_test.go @@ -0,0 +1,44 @@ +package v046_test + +import ( + "testing" + + "github.com/cosmos/cosmos-sdk/testutil" + sdk "github.com/cosmos/cosmos-sdk/types" + moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil" + v046 "github.com/cosmos/cosmos-sdk/x/crisis/migrations/v046" + "github.com/cosmos/cosmos-sdk/x/crisis/types" + "github.com/cosmos/cosmos-sdk/x/distribution" + "github.com/stretchr/testify/require" +) + +type mockSubspace struct { + constantFee sdk.Coin +} + +func newMockSubspace(fee sdk.Coin) mockSubspace { + return mockSubspace{constantFee: fee} +} + +func (ms mockSubspace) Get(ctx sdk.Context, key []byte, ptr interface{}) { + *ptr.(*sdk.Coin) = ms.constantFee +} + +func TestMigrate(t *testing.T) { + encCfg := moduletestutil.MakeTestEncodingConfig(distribution.AppModuleBasic{}) + cdc := encCfg.Codec + + storeKey := sdk.NewKVStoreKey(v046.ModuleName) + tKey := sdk.NewTransientStoreKey("transient_test") + ctx := testutil.DefaultContext(storeKey, tKey) + store := ctx.KVStore(storeKey) + + legacySubspace := newMockSubspace(types.DefaultGenesisState().ConstantFee) + require.NoError(t, v046.MigrateStore(ctx, storeKey, legacySubspace, cdc)) + + var res sdk.Coin + bz := store.Get(v046.ConstantFeeKey) + require.NoError(t, cdc.Unmarshal(bz, &res)) + require.NotNil(t, res) + require.Equal(t, legacySubspace.constantFee, res) +} diff --git a/x/crisis/module.go b/x/crisis/module.go index 4b114baeb5ff..424fcaec3790 100644 --- a/x/crisis/module.go +++ b/x/crisis/module.go @@ -19,16 +19,22 @@ import ( "github.com/cosmos/cosmos-sdk/runtime" "github.com/cosmos/cosmos-sdk/server" servertypes "github.com/cosmos/cosmos-sdk/server/types" + store "github.com/cosmos/cosmos-sdk/store/types" "github.com/cosmos/cosmos-sdk/telemetry" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/module" authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" "github.com/cosmos/cosmos-sdk/x/crisis/client/cli" + "github.com/cosmos/cosmos-sdk/x/crisis/exported" "github.com/cosmos/cosmos-sdk/x/crisis/keeper" "github.com/cosmos/cosmos-sdk/x/crisis/types" + govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" paramstypes "github.com/cosmos/cosmos-sdk/x/params/types" ) +// ConsensusVersion defines the current x/params module consensus version. +const ConsensusVersion = 2 + var ( _ module.AppModule = AppModule{} _ module.AppModuleBasic = AppModuleBasic{} @@ -94,6 +100,9 @@ type AppModule struct { // executed. keeper *keeper.Keeper + // legacySubspace is used solely for migration of x/params managed parameters + legacySubspace exported.Subspace + skipGenesisInvariants bool } @@ -101,10 +110,11 @@ type AppModule struct { // we will call keeper.AssertInvariants during InitGenesis (it may take a significant time) // - which doesn't impact the chain security unless 66+% of validators have a wrongly // modified genesis file. -func NewAppModule(keeper *keeper.Keeper, skipGenesisInvariants bool) AppModule { +func NewAppModule(keeper *keeper.Keeper, skipGenesisInvariants bool, ss exported.Subspace) AppModule { return AppModule{ AppModuleBasic: AppModuleBasic{}, keeper: keeper, + legacySubspace: ss, skipGenesisInvariants: skipGenesisInvariants, } @@ -137,6 +147,11 @@ func (AppModule) LegacyQuerierHandler(*codec.LegacyAmino) sdk.Querier { return n // RegisterServices registers module services. func (am AppModule) RegisterServices(cfg module.Configurator) { types.RegisterMsgServer(cfg.MsgServer(), am.keeper) + + m := keeper.NewMigrator(am.keeper, am.legacySubspace) + if err := cfg.RegisterMigration(types.ModuleName, 1, m.Migrate1to2); err != nil { + panic(fmt.Sprintf("failed to migrate x/%s from version 1 to 2: %v", types.ModuleName, err)) + } } // InitGenesis performs genesis initialization for the crisis module. It returns @@ -162,7 +177,7 @@ func (am AppModule) ExportGenesis(ctx sdk.Context, cdc codec.JSONCodec) json.Raw } // ConsensusVersion implements AppModule/ConsensusVersion. -func (AppModule) ConsensusVersion() uint64 { return 1 } +func (AppModule) ConsensusVersion() uint64 { return ConsensusVersion } // BeginBlock performs a no-op. func (AppModule) BeginBlock(_ sdk.Context, _ abci.RequestBeginBlock) {} @@ -187,6 +202,8 @@ type crisisInputs struct { depinject.In Config *modulev1.Module + Key *store.KVStoreKey + Cdc codec.Codec AppOpts servertypes.AppOptions `optional:"true"` Subspace paramstypes.Subspace BankKeeper types.SupplyKeeper @@ -212,15 +229,17 @@ func provideModule(in crisisInputs) crisisOutputs { } k := keeper.NewKeeper( - in.Subspace, + in.Cdc, + in.Key, invalidCheckPeriod, in.BankKeeper, feeCollectorName, + authtypes.NewModuleAddress(govtypes.ModuleName).String(), ) skipGenesisInvariants := cast.ToBool(in.AppOpts.Get(FlagSkipGenesisInvariants)) - m := NewAppModule(k, skipGenesisInvariants) + m := NewAppModule(k, skipGenesisInvariants, in.Subspace) return crisisOutputs{CrisisKeeper: k, Module: runtime.WrapAppModule(m)} } diff --git a/x/crisis/types/codec.go b/x/crisis/types/codec.go index 324ef56891ea..8df1ab46762e 100644 --- a/x/crisis/types/codec.go +++ b/x/crisis/types/codec.go @@ -14,11 +14,13 @@ import ( // on the provided LegacyAmino codec. These types are used for Amino JSON serialization. func RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) { legacy.RegisterAminoMsg(cdc, &MsgVerifyInvariant{}, "cosmos-sdk/MsgVerifyInvariant") + legacy.RegisterAminoMsg(cdc, &MsgUpdateParams{}, "cosmos-sdk/x/crisis/MsgUpdateParams") } func RegisterInterfaces(registry codectypes.InterfaceRegistry) { registry.RegisterImplementations((*sdk.Msg)(nil), &MsgVerifyInvariant{}, + &MsgUpdateParams{}, ) msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc) diff --git a/x/crisis/types/keys.go b/x/crisis/types/keys.go index 8f009eda4148..9cc09faf5808 100644 --- a/x/crisis/types/keys.go +++ b/x/crisis/types/keys.go @@ -3,4 +3,10 @@ package types const ( // module name ModuleName = "crisis" + + StoreKey = ModuleName +) + +var ( + ConstantFeeKey = []byte{0x01} ) diff --git a/x/crisis/types/params.go b/x/crisis/types/legacy_params.go similarity index 100% rename from x/crisis/types/params.go rename to x/crisis/types/legacy_params.go diff --git a/x/crisis/types/msgs.go b/x/crisis/types/msgs.go index a5450b010e7f..02f37af6f912 100644 --- a/x/crisis/types/msgs.go +++ b/x/crisis/types/msgs.go @@ -5,8 +5,13 @@ import ( sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" ) +const ( + TypeMsgVerifyInvariant = "verify_invariant" + TypeMsgUpdateParams = "update_params" +) + // ensure Msg interface compliance at compile time -var _ sdk.Msg = &MsgVerifyInvariant{} +var _, _ sdk.Msg = &MsgVerifyInvariant{}, &MsgUpdateParams{} // NewMsgVerifyInvariant creates a new MsgVerifyInvariant object //nolint:interfacer @@ -19,7 +24,7 @@ func NewMsgVerifyInvariant(sender sdk.AccAddress, invModeName, invRoute string) } func (msg MsgVerifyInvariant) Route() string { return ModuleName } -func (msg MsgVerifyInvariant) Type() string { return "verify_invariant" } +func (msg MsgVerifyInvariant) Type() string { return TypeMsgVerifyInvariant } // get the bytes for the message signer to sign on func (msg MsgVerifyInvariant) GetSigners() []sdk.AccAddress { @@ -45,3 +50,37 @@ func (msg MsgVerifyInvariant) ValidateBasic() error { func (msg MsgVerifyInvariant) FullInvariantRoute() string { return msg.InvariantModuleName + "/" + msg.InvariantRoute } + +func (msg MsgUpdateParams) Route() string { return ModuleName } +func (msg MsgUpdateParams) Type() string { return TypeMsgUpdateParams } + +// GetSigners returns the signer addresses that are expected to sign the result +// of GetSignBytes. +func (msg MsgUpdateParams) GetSigners() []sdk.AccAddress { + authority, _ := sdk.AccAddressFromBech32(msg.Authority) + return []sdk.AccAddress{authority} +} + +// GetSignBytes returns the raw bytes for a MsgUpdateParams message that +// the expected signer needs to sign. +func (msg MsgUpdateParams) GetSignBytes() []byte { + bz := ModuleCdc.MustMarshalJSON(&msg) + return sdk.MustSortJSON(bz) +} + +// ValidateBasic performs basic MsgUpdateParams message validation. +func (msg MsgUpdateParams) ValidateBasic() error { + if _, err := sdk.AccAddressFromBech32(msg.Authority); err != nil { + return sdkerrors.Wrap(err, "invalid authority address") + } + + if !msg.ConstantFee.IsValid() { + return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, "invalid costant fee") + } + + if msg.ConstantFee.IsNegative() { + return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, "negative costant fee") + } + + return nil +} diff --git a/x/crisis/types/tx.pb.go b/x/crisis/types/tx.pb.go index 412311aace83..a996aab1c068 100644 --- a/x/crisis/types/tx.pb.go +++ b/x/crisis/types/tx.pb.go @@ -7,6 +7,7 @@ import ( context "context" fmt "fmt" _ "github.com/cosmos/cosmos-proto" + types "github.com/cosmos/cosmos-sdk/types" _ "github.com/cosmos/cosmos-sdk/types/msgservice" _ "github.com/gogo/protobuf/gogoproto" grpc1 "github.com/gogo/protobuf/grpc" @@ -107,37 +108,144 @@ func (m *MsgVerifyInvariantResponse) XXX_DiscardUnknown() { var xxx_messageInfo_MsgVerifyInvariantResponse proto.InternalMessageInfo +// MsgUpdateParams is the Msg/UpdateParams request type. +// +// Since: cosmos-sdk 0.47 +type MsgUpdateParams struct { + // authority is the address of the governance account. + Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"` + // constant_fee defines the x/crisis parameter. + ConstantFee types.Coin `protobuf:"bytes,2,opt,name=constant_fee,json=constantFee,proto3" json:"constant_fee"` +} + +func (m *MsgUpdateParams) Reset() { *m = MsgUpdateParams{} } +func (m *MsgUpdateParams) String() string { return proto.CompactTextString(m) } +func (*MsgUpdateParams) ProtoMessage() {} +func (*MsgUpdateParams) Descriptor() ([]byte, []int) { + return fileDescriptor_61276163172fe867, []int{2} +} +func (m *MsgUpdateParams) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgUpdateParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgUpdateParams.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *MsgUpdateParams) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgUpdateParams.Merge(m, src) +} +func (m *MsgUpdateParams) XXX_Size() int { + return m.Size() +} +func (m *MsgUpdateParams) XXX_DiscardUnknown() { + xxx_messageInfo_MsgUpdateParams.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgUpdateParams proto.InternalMessageInfo + +func (m *MsgUpdateParams) GetAuthority() string { + if m != nil { + return m.Authority + } + return "" +} + +func (m *MsgUpdateParams) GetConstantFee() types.Coin { + if m != nil { + return m.ConstantFee + } + return types.Coin{} +} + +// MsgUpdateParamsResponse defines the response structure for executing a +// MsgUpdateParams message. +// +// Since: cosmos-sdk 0.47 +type MsgUpdateParamsResponse struct { +} + +func (m *MsgUpdateParamsResponse) Reset() { *m = MsgUpdateParamsResponse{} } +func (m *MsgUpdateParamsResponse) String() string { return proto.CompactTextString(m) } +func (*MsgUpdateParamsResponse) ProtoMessage() {} +func (*MsgUpdateParamsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_61276163172fe867, []int{3} +} +func (m *MsgUpdateParamsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgUpdateParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgUpdateParamsResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *MsgUpdateParamsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgUpdateParamsResponse.Merge(m, src) +} +func (m *MsgUpdateParamsResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgUpdateParamsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgUpdateParamsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgUpdateParamsResponse proto.InternalMessageInfo + func init() { proto.RegisterType((*MsgVerifyInvariant)(nil), "cosmos.crisis.v1beta1.MsgVerifyInvariant") proto.RegisterType((*MsgVerifyInvariantResponse)(nil), "cosmos.crisis.v1beta1.MsgVerifyInvariantResponse") + proto.RegisterType((*MsgUpdateParams)(nil), "cosmos.crisis.v1beta1.MsgUpdateParams") + proto.RegisterType((*MsgUpdateParamsResponse)(nil), "cosmos.crisis.v1beta1.MsgUpdateParamsResponse") } func init() { proto.RegisterFile("cosmos/crisis/v1beta1/tx.proto", fileDescriptor_61276163172fe867) } var fileDescriptor_61276163172fe867 = []byte{ - // 342 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4b, 0xce, 0x2f, 0xce, - 0xcd, 0x2f, 0xd6, 0x4f, 0x2e, 0xca, 0x2c, 0xce, 0x2c, 0xd6, 0x2f, 0x33, 0x4c, 0x4a, 0x2d, 0x49, - 0x34, 0xd4, 0x2f, 0xa9, 0xd0, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x85, 0xc8, 0xeb, 0x41, - 0xe4, 0xf5, 0xa0, 0xf2, 0x52, 0x22, 0xe9, 0xf9, 0xe9, 0xf9, 0x60, 0x15, 0xfa, 0x20, 0x16, 0x44, - 0xb1, 0x94, 0x24, 0x44, 0x71, 0x3c, 0x44, 0x02, 0xaa, 0x13, 0x22, 0x25, 0x0e, 0xb5, 0x27, 0xb7, - 0x38, 0x5d, 0xbf, 0xcc, 0x10, 0x44, 0x41, 0x24, 0x94, 0x76, 0x30, 0x72, 0x09, 0xf9, 0x16, 0xa7, - 0x87, 0xa5, 0x16, 0x65, 0xa6, 0x55, 0x7a, 0xe6, 0x95, 0x25, 0x16, 0x65, 0x26, 0xe6, 0x95, 0x08, - 0x19, 0x70, 0xb1, 0x15, 0xa7, 0xe6, 0xa5, 0xa4, 0x16, 0x49, 0x30, 0x2a, 0x30, 0x6a, 0x70, 0x3a, - 0x49, 0x5c, 0xda, 0xa2, 0x2b, 0x02, 0x35, 0xd1, 0x31, 0x25, 0xa5, 0x28, 0xb5, 0xb8, 0x38, 0xb8, - 0xa4, 0x28, 0x33, 0x2f, 0x3d, 0x08, 0xaa, 0x4e, 0xc8, 0x88, 0x4b, 0x34, 0x13, 0xa6, 0x3d, 0x3e, - 0x37, 0x3f, 0xa5, 0x34, 0x27, 0x35, 0x3e, 0x2f, 0x31, 0x37, 0x55, 0x82, 0x09, 0x64, 0x40, 0x90, - 0x30, 0x5c, 0xd2, 0x17, 0x2c, 0xe7, 0x97, 0x98, 0x9b, 0x2a, 0xa4, 0xce, 0xc5, 0x8f, 0xd0, 0x53, - 0x94, 0x5f, 0x5a, 0x92, 0x2a, 0xc1, 0x0c, 0x56, 0xcd, 0x07, 0x17, 0x0e, 0x02, 0x89, 0x5a, 0x09, - 0x77, 0x2c, 0x90, 0x67, 0x78, 0xb1, 0x40, 0x9e, 0xa1, 0xe9, 0xf9, 0x06, 0x2d, 0xa8, 0x8d, 0x4a, - 0x32, 0x5c, 0x52, 0x98, 0x2e, 0x0f, 0x4a, 0x2d, 0x2e, 0xc8, 0xcf, 0x2b, 0x4e, 0x35, 0x2a, 0xe3, - 0x62, 0xf6, 0x2d, 0x4e, 0x17, 0xca, 0xe7, 0xe2, 0x47, 0xf7, 0x9b, 0xa6, 0x1e, 0xd6, 0x40, 0xd5, - 0xc3, 0x34, 0x4c, 0xca, 0x90, 0x68, 0xa5, 0x30, 0x7b, 0x9d, 0x5c, 0x4f, 0x3c, 0x92, 0x63, 0xbc, - 0xf0, 0x48, 0x8e, 0xf1, 0xc1, 0x23, 0x39, 0xc6, 0x09, 0x8f, 0xe5, 0x18, 0x2e, 0x3c, 0x96, 0x63, - 0xb8, 0xf1, 0x58, 0x8e, 0x21, 0x4a, 0x3b, 0x3d, 0xb3, 0x24, 0xa3, 0x34, 0x49, 0x2f, 0x39, 0x3f, - 0x57, 0x1f, 0x16, 0xed, 0x60, 0x4a, 0xb7, 0x38, 0x25, 0x5b, 0xbf, 0x02, 0x96, 0x06, 0x4a, 0x2a, - 0x0b, 0x52, 0x8b, 0x93, 0xd8, 0xc0, 0xd1, 0x63, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0x69, 0x76, - 0x6c, 0x9d, 0x21, 0x02, 0x00, 0x00, + // 467 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x53, 0xbf, 0x6f, 0x13, 0x31, + 0x14, 0xbe, 0xa3, 0xa8, 0x52, 0xdd, 0xaa, 0x91, 0xdc, 0x56, 0x4d, 0x4e, 0xe8, 0x82, 0x32, 0xf0, + 0x53, 0xf5, 0x91, 0x20, 0x31, 0x74, 0x23, 0x08, 0x24, 0x86, 0x20, 0x74, 0x08, 0x06, 0x96, 0xc8, + 0xb9, 0x7b, 0xb9, 0x5a, 0x70, 0x76, 0xe4, 0xe7, 0x44, 0xcd, 0xca, 0xc4, 0xc8, 0x3f, 0x80, 0xd4, + 0x3f, 0x81, 0x81, 0x81, 0x3f, 0xa1, 0x63, 0xc5, 0xc4, 0x54, 0xa1, 0x64, 0x80, 0x3f, 0x03, 0xdd, + 0x9d, 0x9d, 0x40, 0x0b, 0x22, 0x93, 0x2d, 0x7f, 0xdf, 0xf7, 0xbe, 0xcf, 0xcf, 0x7e, 0x24, 0x4c, + 0x14, 0xe6, 0x0a, 0xa3, 0x44, 0x0b, 0x14, 0x18, 0x4d, 0xda, 0x03, 0x30, 0xbc, 0x1d, 0x99, 0x63, + 0x36, 0xd2, 0xca, 0x28, 0xba, 0x57, 0xe1, 0xac, 0xc2, 0x99, 0xc5, 0x83, 0xdd, 0x4c, 0x65, 0xaa, + 0x64, 0x44, 0xc5, 0xae, 0x22, 0x07, 0x8d, 0x8a, 0xdc, 0xaf, 0x00, 0xab, 0xac, 0xa0, 0x7d, 0xeb, + 0x93, 0x63, 0x16, 0x4d, 0xda, 0xc5, 0x62, 0x01, 0x17, 0x60, 0xc0, 0x11, 0x16, 0xf6, 0x89, 0x12, + 0xb2, 0xc2, 0x5b, 0x5f, 0x7c, 0x42, 0x7b, 0x98, 0xbd, 0x02, 0x2d, 0x86, 0xd3, 0xa7, 0x72, 0xc2, + 0xb5, 0xe0, 0xd2, 0xd0, 0x7b, 0x64, 0x1d, 0x41, 0xa6, 0xa0, 0xeb, 0xfe, 0x75, 0xff, 0xd6, 0x46, + 0xb7, 0xfe, 0xf5, 0xf3, 0xc1, 0xae, 0x75, 0x7c, 0x98, 0xa6, 0x1a, 0x10, 0x5f, 0x18, 0x2d, 0x64, + 0x16, 0x5b, 0x1e, 0xed, 0x90, 0x3d, 0xe1, 0xe4, 0xfd, 0x5c, 0xa5, 0xe3, 0xb7, 0xd0, 0x97, 0x3c, + 0x87, 0xfa, 0x95, 0xa2, 0x40, 0xbc, 0xb3, 0x00, 0x7b, 0x25, 0xf6, 0x8c, 0xe7, 0x40, 0x6f, 0x92, + 0xda, 0x52, 0xa3, 0xd5, 0xd8, 0x40, 0x7d, 0xad, 0x64, 0x6f, 0x2f, 0x8e, 0xe3, 0xe2, 0xf4, 0x70, + 0xe7, 0xfd, 0x49, 0xd3, 0xfb, 0x79, 0xd2, 0xf4, 0xde, 0xfd, 0xf8, 0x74, 0xc7, 0x3a, 0xb6, 0xae, + 0x91, 0xe0, 0x72, 0xf2, 0x18, 0x70, 0xa4, 0x24, 0x42, 0xeb, 0xa3, 0x4f, 0x6a, 0x3d, 0xcc, 0x5e, + 0x8e, 0x52, 0x6e, 0xe0, 0x39, 0xd7, 0x3c, 0x47, 0xfa, 0x80, 0x6c, 0xf0, 0xb1, 0x39, 0x52, 0x5a, + 0x98, 0xe9, 0x7f, 0x2f, 0xb6, 0xa4, 0xd2, 0x2e, 0xd9, 0x4a, 0x94, 0x44, 0x53, 0xc4, 0x1c, 0x42, + 0x75, 0xa5, 0xcd, 0x4e, 0x83, 0x59, 0x5d, 0xd1, 0x5b, 0xf7, 0x74, 0xec, 0x91, 0x12, 0xb2, 0x7b, + 0xf5, 0xf4, 0xbc, 0xe9, 0xc5, 0x9b, 0x4e, 0xf4, 0x04, 0xe0, 0x70, 0xbb, 0x88, 0xbe, 0xac, 0xd9, + 0x6a, 0x90, 0xfd, 0x0b, 0xf1, 0x5c, 0xf4, 0xce, 0xb9, 0x4f, 0xd6, 0x7a, 0x98, 0x51, 0x45, 0x6a, + 0x17, 0xdf, 0xe5, 0x36, 0xfb, 0xeb, 0x87, 0x61, 0x97, 0x1b, 0x11, 0xb4, 0x57, 0xa6, 0x3a, 0x63, + 0x3a, 0x24, 0x5b, 0x7f, 0xf4, 0xeb, 0xc6, 0xbf, 0x4b, 0xfc, 0xce, 0x0b, 0xd8, 0x6a, 0x3c, 0xe7, + 0xd3, 0x7d, 0x7c, 0x3a, 0x0b, 0xfd, 0xb3, 0x59, 0xe8, 0x7f, 0x9f, 0x85, 0xfe, 0x87, 0x79, 0xe8, + 0x9d, 0xcd, 0x43, 0xef, 0xdb, 0x3c, 0xf4, 0x5e, 0xdf, 0xcd, 0x84, 0x39, 0x1a, 0x0f, 0x58, 0xa2, + 0xf2, 0xc8, 0x8d, 0x4e, 0xb9, 0x1c, 0x60, 0xfa, 0x26, 0x3a, 0x76, 0x73, 0x64, 0xa6, 0x23, 0xc0, + 0xc1, 0x7a, 0xf9, 0x85, 0xef, 0xff, 0x0a, 0x00, 0x00, 0xff, 0xff, 0x34, 0x0c, 0xab, 0x77, 0x65, + 0x03, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -154,6 +262,11 @@ const _ = grpc.SupportPackageIsVersion4 type MsgClient interface { // VerifyInvariant defines a method to verify a particular invariance. VerifyInvariant(ctx context.Context, in *MsgVerifyInvariant, opts ...grpc.CallOption) (*MsgVerifyInvariantResponse, error) + // UpdateParams defines a governance operation for updating the x/crisis module + // parameters. The authority is defined in the keeper. + // + // Since: cosmos-sdk 0.47 + UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) } type msgClient struct { @@ -173,10 +286,24 @@ func (c *msgClient) VerifyInvariant(ctx context.Context, in *MsgVerifyInvariant, return out, nil } +func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) { + out := new(MsgUpdateParamsResponse) + err := c.cc.Invoke(ctx, "/cosmos.crisis.v1beta1.Msg/UpdateParams", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // MsgServer is the server API for Msg service. type MsgServer interface { // VerifyInvariant defines a method to verify a particular invariance. VerifyInvariant(context.Context, *MsgVerifyInvariant) (*MsgVerifyInvariantResponse, error) + // UpdateParams defines a governance operation for updating the x/crisis module + // parameters. The authority is defined in the keeper. + // + // Since: cosmos-sdk 0.47 + UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error) } // UnimplementedMsgServer can be embedded to have forward compatible implementations. @@ -186,6 +313,9 @@ type UnimplementedMsgServer struct { func (*UnimplementedMsgServer) VerifyInvariant(ctx context.Context, req *MsgVerifyInvariant) (*MsgVerifyInvariantResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method VerifyInvariant not implemented") } +func (*UnimplementedMsgServer) UpdateParams(ctx context.Context, req *MsgUpdateParams) (*MsgUpdateParamsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateParams not implemented") +} func RegisterMsgServer(s grpc1.Server, srv MsgServer) { s.RegisterService(&_Msg_serviceDesc, srv) @@ -209,6 +339,24 @@ func _Msg_VerifyInvariant_Handler(srv interface{}, ctx context.Context, dec func return interceptor(ctx, in, info, handler) } +func _Msg_UpdateParams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgUpdateParams) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).UpdateParams(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmos.crisis.v1beta1.Msg/UpdateParams", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).UpdateParams(ctx, req.(*MsgUpdateParams)) + } + return interceptor(ctx, in, info, handler) +} + var _Msg_serviceDesc = grpc.ServiceDesc{ ServiceName: "cosmos.crisis.v1beta1.Msg", HandlerType: (*MsgServer)(nil), @@ -217,6 +365,10 @@ var _Msg_serviceDesc = grpc.ServiceDesc{ MethodName: "VerifyInvariant", Handler: _Msg_VerifyInvariant_Handler, }, + { + MethodName: "UpdateParams", + Handler: _Msg_UpdateParams_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "cosmos/crisis/v1beta1/tx.proto", @@ -289,6 +441,69 @@ func (m *MsgVerifyInvariantResponse) MarshalToSizedBuffer(dAtA []byte) (int, err return len(dAtA) - i, nil } +func (m *MsgUpdateParams) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgUpdateParams) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgUpdateParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.ConstantFee.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + if len(m.Authority) > 0 { + i -= len(m.Authority) + copy(dAtA[i:], m.Authority) + i = encodeVarintTx(dAtA, i, uint64(len(m.Authority))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgUpdateParamsResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgUpdateParamsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgUpdateParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + func encodeVarintTx(dAtA []byte, offset int, v uint64) int { offset -= sovTx(v) base := offset @@ -330,6 +545,30 @@ func (m *MsgVerifyInvariantResponse) Size() (n int) { return n } +func (m *MsgUpdateParams) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Authority) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = m.ConstantFee.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgUpdateParamsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + func sovTx(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } @@ -532,6 +771,171 @@ func (m *MsgVerifyInvariantResponse) Unmarshal(dAtA []byte) error { } return nil } +func (m *MsgUpdateParams) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgUpdateParams: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgUpdateParams: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Authority = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ConstantFee", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ConstantFee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgUpdateParamsResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgUpdateParamsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgUpdateParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipTx(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 From 901a2047e46fbd2a02b461d5a185b2d9dfa643d8 Mon Sep 17 00:00:00 2001 From: Nathan Dias Date: Tue, 12 Jul 2022 01:59:31 -0500 Subject: [PATCH 35/37] fix: store/rootmulti: fix non-deterministic map iteration (#12487) ## Description This change fixes non-deterministic map iteration over rs.stores from (*Store).buildCommitInfo by instead sorting the keys then iterating over the sorted slice. Fixes https://github.com/cosmos/cosmos-sdk/issues/12429 --- ### Author Checklist *All items are required. Please add a note to the item if the item is not applicable and please add links to any relevant follow up issues.* I have... - [x] included the correct [type prefix](https://github.com/commitizen/conventional-commit-types/blob/v3.0.0/index.json) in the PR title - [x] added `!` to the type prefix if API or client breaking change - [x] targeted the correct branch (see [PR Targeting](https://github.com/cosmos/cosmos-sdk/blob/main/CONTRIBUTING.md#pr-targeting)) - [x] provided a link to the relevant issue or specification - [x] followed the guidelines for [building modules](https://github.com/cosmos/cosmos-sdk/blob/main/docs/building-modules) - [x] included the necessary unit and integration [tests](https://github.com/cosmos/cosmos-sdk/blob/main/CONTRIBUTING.md#testing) - [x] added a changelog entry to `CHANGELOG.md` - [x] included comments for [documenting Go code](https://blog.golang.org/godoc) - [x] updated the relevant documentation or specification - [x] reviewed "Files changed" and left comments if necessary - [x] confirmed all CI checks have passed ### Reviewers Checklist *All items are required. Please add a note if the item is not applicable and please add your handle next to the items reviewed if you only reviewed selected items.* I have... - [ ] confirmed the correct [type prefix](https://github.com/commitizen/conventional-commit-types/blob/v3.0.0/index.json) in the PR title - [ ] confirmed `!` in the type prefix if API or client breaking change - [ ] confirmed all author checklist items have been addressed - [ ] reviewed state machine logic - [ ] reviewed API design and naming - [ ] reviewed documentation is accurate - [ ] reviewed tests and test coverage - [ ] manually tested (if applicable) --- CHANGELOG.md | 1 + store/rootmulti/store.go | 11 ++++++++++- 2 files changed, 11 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 2de9127aaeaa..5e0aad63f8c1 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -100,6 +100,7 @@ Ref: https://keepachangelog.com/en/1.0.0/ empty coins slice before it is used to create `banktype.MsgSend`. * (x/auth/tx) [#12474](https://github.com/cosmos/cosmos-sdk/pull/12474) Remove condition in GetTxsEvent that disallowed multiple equal signs, which would break event queries with base64 strings (i.e. query by signature). * [#12448](https://github.com/cosmos/cosmos-sdk/pull/12448) Start telemetry independently from the API server. +* (store/rootmulti) [#12487](https://github.com/cosmos/cosmos-sdk/pull/12487) Fix non-deterministic map iteration. ## [v0.46.0-rc1](https://github.com/cosmos/cosmos-sdk/releases/tag/v0.46.0-rc1) - 2022-05-23 diff --git a/store/rootmulti/store.go b/store/rootmulti/store.go index d31cb2e42b03..7a046959f92f 100644 --- a/store/rootmulti/store.go +++ b/store/rootmulti/store.go @@ -907,8 +907,17 @@ func (rs *Store) loadCommitStoreFromParams(key types.StoreKey, id types.CommitID } func (rs *Store) buildCommitInfo(version int64) *types.CommitInfo { + keys := make([]types.StoreKey, 0, len(rs.stores)) + for key := range rs.stores { + keys = append(keys, key) + } + sort.Slice(keys, func(i, j int) bool { + return keys[i].Name() < keys[j].Name() + }) + storeInfos := []types.StoreInfo{} - for key, store := range rs.stores { + for _, key := range keys { + store := rs.stores[key] if store.GetStoreType() == types.StoreTypeTransient { continue } From acdb3a908eaee3e18e9d1a0d2e124e31f955e246 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 12 Jul 2022 07:37:39 +0000 Subject: [PATCH 36/37] build(deps): Bump github.com/prometheus/common from 0.35.0 to 0.36.0 (#12529) Bumps [github.com/prometheus/common](https://github.com/prometheus/common) from 0.35.0 to 0.36.0.
Release notes

Sourced from github.com/prometheus/common's releases.

sigv4/v0.1.0

Initial release

Commits
  • c5e1b60 config: ignore deprecated warning in tests (#389)
  • b86ea81 OAuth2: Respect disable keepalives option; Implement close idle connections (...
  • cdc09f0 Merge pull request #387 from roidelapluie/useragent
  • d75e027 Merge pull request #388 from simonpasquier/fix-tls-tests-for-go-1.18
  • aeda642 Update to Go 1.18
  • db0284d Fix comment
  • 5ab1c85 config: fix testdata for Go 1.18
  • 2d0de85 Use full roundtripper
  • 316097c Use WithUserAgent
  • 99a1aca add User-Agent header to oauth2 requests
  • See full diff in compare view

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=github.com/prometheus/common&package-manager=go_modules&previous-version=0.35.0&new-version=0.36.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores) Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@dependabot rebase`. [//]: # (dependabot-automerge-start) [//]: # (dependabot-automerge-end) ---
Dependabot commands and options
You can trigger Dependabot actions by commenting on this PR: - `@dependabot rebase` will rebase this PR - `@dependabot recreate` will recreate this PR, overwriting any edits that have been made to it - `@dependabot merge` will merge this PR after your CI passes on it - `@dependabot squash and merge` will squash and merge this PR after your CI passes on it - `@dependabot cancel merge` will cancel a previously requested merge and block automerging - `@dependabot reopen` will reopen this PR if it is closed - `@dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually - `@dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself) - `@dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
--- go.mod | 2 +- go.sum | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/go.mod b/go.mod index 01f6472bb5a0..d4f170f203bd 100644 --- a/go.mod +++ b/go.mod @@ -43,7 +43,7 @@ require ( github.com/mattn/go-isatty v0.0.14 github.com/pkg/errors v0.9.1 github.com/prometheus/client_golang v1.12.2 - github.com/prometheus/common v0.35.0 + github.com/prometheus/common v0.36.0 github.com/rakyll/statik v0.1.7 github.com/regen-network/cosmos-proto v0.3.1 github.com/rs/zerolog v1.27.0 diff --git a/go.sum b/go.sum index ee55e89b6965..a733d703ad77 100644 --- a/go.sum +++ b/go.sum @@ -1090,8 +1090,8 @@ github.com/prometheus/common v0.15.0/go.mod h1:U+gB1OBLb1lF3O42bTCL+FK18tX9Oar16 github.com/prometheus/common v0.26.0/go.mod h1:M7rCNAaPfAosfx8veZJCuw84e35h3Cfd9VFqTh1DIvc= github.com/prometheus/common v0.30.0/go.mod h1:vu+V0TpY+O6vW9J44gczi3Ap/oXXR10b+M/gUGO4Hls= github.com/prometheus/common v0.32.1/go.mod h1:vu+V0TpY+O6vW9J44gczi3Ap/oXXR10b+M/gUGO4Hls= -github.com/prometheus/common v0.35.0 h1:Eyr+Pw2VymWejHqCugNaQXkAi6KayVNxaHeu6khmFBE= -github.com/prometheus/common v0.35.0/go.mod h1:phzohg0JFMnBEFGxTDbfu3QyL5GI8gTQJFhYO5B3mfA= +github.com/prometheus/common v0.36.0 h1:78hJTing+BLYLjhXE+Z2BubeEymH5Lr0/Mt8FKkxxYo= +github.com/prometheus/common v0.36.0/go.mod h1:phzohg0JFMnBEFGxTDbfu3QyL5GI8gTQJFhYO5B3mfA= github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk= github.com/prometheus/procfs v0.0.0-20190117184657-bf6a532e95b1/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk= github.com/prometheus/procfs v0.0.0-20190507164030-5867b95ac084/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA= @@ -2073,7 +2073,7 @@ gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gotest.tools v2.2.0+incompatible h1:VsBPFP1AI068pPrMxtb/S8Zkgf9xEmTLJjfM+P5UIEo= gotest.tools v2.2.0+incompatible/go.mod h1:DsYFclhRJ6vuDpmuTbkuFWG+y2sxOXAzmJt81HFBacw= -gotest.tools/v3 v3.2.0 h1:I0DwBVMGAx26dttAj1BtJLAkVGncrkkUXfJLC4Flt/I= +gotest.tools/v3 v3.3.0 h1:MfDY1b1/0xN1CyMlQDac0ziEy9zJQd9CXBRRDHw2jJo= honnef.co/go/tools v0.0.0-20180728063816-88497007e858/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= From 055989339d41e374859e96fecf7cb7bff3c99234 Mon Sep 17 00:00:00 2001 From: atheeshp <59333759+atheeshp@users.noreply.github.com> Date: Tue, 12 Jul 2022 13:34:44 +0530 Subject: [PATCH 37/37] fix: (x/crisis) failing tests for legacy app (#12536) --- simapp/app_legacy.go | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/simapp/app_legacy.go b/simapp/app_legacy.go index 37db22adcaed..f0aa6f7b8df5 100644 --- a/simapp/app_legacy.go +++ b/simapp/app_legacy.go @@ -217,7 +217,7 @@ func NewSimApp( bApp.SetInterfaceRegistry(interfaceRegistry) keys := sdk.NewKVStoreKeys( - authtypes.StoreKey, banktypes.StoreKey, stakingtypes.StoreKey, + authtypes.StoreKey, banktypes.StoreKey, stakingtypes.StoreKey, crisistypes.StoreKey, minttypes.StoreKey, distrtypes.StoreKey, slashingtypes.StoreKey, govtypes.StoreKey, paramstypes.StoreKey, upgradetypes.StoreKey, feegrant.StoreKey, evidencetypes.StoreKey, capabilitytypes.StoreKey, @@ -272,9 +272,8 @@ func NewSimApp( ) invCheckPeriod := cast.ToUint(appOpts.Get(server.FlagInvCheckPeriod)) - app.CrisisKeeper = crisiskeeper.NewKeeper( - app.GetSubspace(crisistypes.ModuleName), invCheckPeriod, app.BankKeeper, authtypes.FeeCollectorName, - ) + app.CrisisKeeper = crisiskeeper.NewKeeper(appCodec, keys[crisistypes.StoreKey], invCheckPeriod, + app.BankKeeper, authtypes.FeeCollectorName, authtypes.NewModuleAddress(govtypes.ModuleName).String()) app.FeeGrantKeeper = feegrantkeeper.NewKeeper(appCodec, keys[feegrant.StoreKey], app.AccountKeeper) @@ -356,7 +355,7 @@ func NewSimApp( vesting.NewAppModule(app.AccountKeeper, app.BankKeeper), bank.NewAppModule(appCodec, app.BankKeeper, app.AccountKeeper), capability.NewAppModule(appCodec, *app.CapabilityKeeper, false), - crisis.NewAppModule(app.CrisisKeeper, skipGenesisInvariants), + crisis.NewAppModule(app.CrisisKeeper, skipGenesisInvariants, app.GetSubspace(crisistypes.ModuleName)), feegrantmodule.NewAppModule(appCodec, app.AccountKeeper, app.BankKeeper, app.FeeGrantKeeper, app.interfaceRegistry), gov.NewAppModule(appCodec, &app.GovKeeper, app.AccountKeeper, app.BankKeeper), mint.NewAppModule(appCodec, app.MintKeeper, app.AccountKeeper, nil, app.GetSubspace(minttypes.ModuleName)),
Release notes

Sourced from github.com/spf13/cobra's releases.

v1.5.0

Spring 2022 Release 🌥️

Hello everyone! Welcome to another release of cobra. Completions continue to get better and better. This release adds a few really cool new features. We also continue to patch versions of our dependencies as they become available via dependabot. Happy coding!

Active help 👐🏼

Shout out to @​marckhouzam for a big value add: Active Help spf13/cobra#1482. With active help, a program can provide some inline warnings or hints for users as they hit tab. Now, your CLIs can be even more intuitive to use!

Currently active help is only supported for bash V2 and zsh. Marc wrote a whole guide on how to do this, so make sure to give it a good read to learn how you can add this to your cobra code! https://github.com/spf13/cobra/blob/master/active_help.md

Group flags 🧑🏼‍🤝‍🧑🏼

Cobra now has the ability to mark flags as required or exclusive as a group. Shout out to our newest maintainer @​johnSchnake for this! spf13/cobra#1654 Let's say you have a username flag that MUST be partnered with a password flag. Well, now, you can enforce those as being required together:

rootCmd.Flags().StringVarP(&u, "username", "u", "", "Username (required if password is set)")
rootCmd.Flags().StringVarP(&pw, "password", "p", "", "Password (required if username is set)")
rootCmd.MarkFlagsRequiredTogether("username", "password")

Flags may also be marked as "mutally exclusive" with the MarkFlagsMutuallyExclusive(string, string ... ) command API. Refer to our user guide documentation for further info!

Completions 👀

Documentation 📝

... (truncated)