Start migration

x/bank/client/cli/query.go

@@ -2,6 +2,7 @@ package cli
 
 import (
 	"fmt"
+	"strings"
 
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
@@ -11,6 +12,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/client/flags"
 	"github.com/cosmos/cosmos-sdk/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/version"
 	"github.com/cosmos/cosmos-sdk/x/bank/types"
 )
 
@@ -28,7 +30,10 @@ func NewQueryCmd(m codec.Marshaler) *cobra.Command {
 		RunE:                       client.ValidateCmd,
 	}
 
-	cmd.AddCommand(NewBalancesCmd(m))
+	cmd.AddCommand(
+		NewBalancesCmd(m),
+		NewQueryTotalSupplyCmd(m),
+	)
 
 	return cmd
 }
@@ -97,6 +102,39 @@ func NewBalancesCmd(m codec.Marshaler) *cobra.Command {
 	return flags.GetCommands(cmd)[0]
 }
 
+// NewQueryTotalSupplyCmd returns a CLI command handler for querying total supply.
+func NewQueryTotalSupplyCmd(m codec.Marshaler) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "total [denom]",
+		Args:  cobra.MaximumNArgs(1),
+		Short: "Query the total supply of coins of the chain",
+		Long: strings.TrimSpace(
+			fmt.Sprintf(`Query total supply of coins that are held by accounts in the
+			chain.
+
+Example:
+$ %s query %s total
+
+To query for the total supply of a specific coin denomination use:
+$ %s query %s total stake
+`,
+				version.ClientName, types.ModuleName, version.ClientName, types.ModuleName,
+			),
+		),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			cliCtx := context.NewCLIContext().WithMarshaler(m)
+
+			if len(args) == 0 {
+				return queryTotalSupply(cliCtx, m)
+			}
+
+			return querySupplyOf(cliCtx, m, args[0])
+		},
+	}
+
+	return flags.GetCommands(cmd)[0]
+}
+
 // ---------------------------------------------------------------------------
 // Deprecated
 //
@@ -116,7 +154,10 @@ func GetQueryCmd(cdc *codec.Codec) *cobra.Command {
 		RunE:                       client.ValidateCmd,
 	}
 
-	cmd.AddCommand(GetBalancesCmd(cdc))
+	cmd.AddCommand(
+		GetBalancesCmd(cdc),
+		GetCmdQueryTotalSupply(cdc),
+	)
 
 	return cmd
 }
@@ -188,3 +229,37 @@ func GetBalancesCmd(cdc *codec.Codec) *cobra.Command {
 
 	return flags.GetCommands(cmd)[0]
 }
+
+// TODO: Remove once client-side Protobuf migration has been completed.
+// ref: https://github.com/cosmos/cosmos-sdk/issues/5864
+func GetCmdQueryTotalSupply(cdc *codec.Codec) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "total [denom]",
+		Args:  cobra.MaximumNArgs(1),
+		Short: "Query the total supply of coins of the chain",
+		Long: strings.TrimSpace(
+			fmt.Sprintf(`Query total supply of coins that are held by accounts in the
+			chain.
+
+Example:
+$ %s query %s total
+
+To query for the total supply of a specific coin denomination use:
+$ %s query %s total stake
+`,
+				version.ClientName, types.ModuleName, version.ClientName, types.ModuleName,
+			),
+		),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			cliCtx := context.NewCLIContext().WithCodec(cdc)
+
+			if len(args) == 0 {
+				return queryTotalSupply(cliCtx, cdc)
+			}
+
+			return querySupplyOf(cliCtx, cdc, args[0])
+		},
+	}
+
+	return flags.GetCommands(cmd)[0]
+}

x/bank/client/cli/util.go

@@ -0,0 +1,51 @@
+package cli
+
+import (
+	"fmt"
+
+	"github.com/cosmos/cosmos-sdk/client/context"
+	"github.com/cosmos/cosmos-sdk/codec"
+	"github.com/cosmos/cosmos-sdk/x/bank/types"
+)
+
+func queryTotalSupply(cliCtx context.CLIContext, m codec.Marshaler) error {
+	params := types.NewQueryTotalSupplyParams(1, 0) // no pagination
+	bz, err := m.MarshalJSON(params)
+	if err != nil {
+		return err
+	}
+
+	res, _, err := cliCtx.QueryWithData(fmt.Sprintf("custom/%s/%s", types.QuerierRoute, types.QueryTotalSupply), bz)
+	if err != nil {
+		return err
+	}
+
+	var totalSupply sdk.Coins
+	err = m.UnmarshalJSON(res, &totalSupply)
+	if err != nil {
+		return err
+	}
+
+	return cliCtx.PrintOutput(totalSupply)
+}
+
+func querySupplyOf(cliCtx context.CLIContext, m codec.Marshaler, denom string) error {
+	params := types.NewQuerySupplyOfParams(denom)
+	bz, err := m.MarshalJSON(params)
+	if err != nil {
+		return err
+	}
+
+	res, _, err := cliCtx.QueryWithData(fmt.Sprintf("custom/%s/%s", types.QuerierRoute, types.QuerySupplyOf), bz)
+	if err != nil {
+		return err
+	}
+
+	var supply sdk.Int
+	err = m.UnmarshalJSON(res, &supply)
+	if err != nil {
+		return err
+	}
+
+	return cliCtx.PrintOutput(supply)
+}

x/bank/client/rest/query.go

@@ -69,3 +69,57 @@ func QueryBalancesRequestHandlerFn(ctx context.CLIContext) http.HandlerFunc {
 		rest.PostProcessResponse(w, ctx, res)
 	}
 }
+
+// HTTP request handler to query the total supply of coins
+func totalSupplyHandlerFn(cliCtx context.CLIContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		_, page, limit, err := rest.ParseHTTPArgsWithLimit(r, 0)
+		if rest.CheckBadRequestError(w, err) {
+			return
+		}
+
+		cliCtx, ok := rest.ParseQueryHeightOrReturnBadRequest(w, cliCtx, r)
+		if !ok {
+			return
+		}
+
+		params := types.NewQueryTotalSupplyParams(page, limit)
+		bz, err := cliCtx.Codec.MarshalJSON(params)
+		if rest.CheckBadRequestError(w, err) {
+			return
+		}
+
+		res, height, err := cliCtx.QueryWithData(fmt.Sprintf("custom/%s/%s", types.QuerierRoute, types.QueryTotalSupply), bz)
+		if rest.CheckInternalServerError(w, err) {
+			return
+		}
+
+		cliCtx = cliCtx.WithHeight(height)
+		rest.PostProcessResponse(w, cliCtx, res)
+	}
+}
+
+// HTTP request handler to query the supply of a single denom
+func supplyOfHandlerFn(cliCtx context.CLIContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		denom := mux.Vars(r)["denom"]
+		cliCtx, ok := rest.ParseQueryHeightOrReturnBadRequest(w, cliCtx, r)
+		if !ok {
+			return
+		}
+
+		params := types.NewQuerySupplyOfParams(denom)
+		bz, err := cliCtx.Codec.MarshalJSON(params)
+		if rest.CheckBadRequestError(w, err) {
+			return
+		}
+
+		res, height, err := cliCtx.QueryWithData(fmt.Sprintf("custom/%s/%s", types.QuerierRoute, types.QuerySupplyOf), bz)
+		if rest.CheckInternalServerError(w, err) {
+			return
+		}
+
+		cliCtx = cliCtx.WithHeight(height)
+		rest.PostProcessResponse(w, cliCtx, res)
+	}
+}

x/bank/client/rest/rest.go

@@ -25,4 +25,6 @@ func RegisterHandlers(ctx context.CLIContext, m codec.Marshaler, txg tx.Generato
 func RegisterRoutes(cliCtx context.CLIContext, r *mux.Router) {
 	r.HandleFunc("/bank/accounts/{address}/transfers", SendRequestHandlerFn(cliCtx)).Methods("POST")
 	r.HandleFunc("/bank/balances/{address}", QueryBalancesRequestHandlerFn(cliCtx)).Methods("GET")
+	r.HandleFunc("/bank/total", totalSupplyHandlerFn(cliCtx)).Methods("GET")
+	r.HandleFunc("/bank/total/{denom}", supplyOfHandlerFn(cliCtx)).Methods("GET")
 }

x/bank/exported/exported.go

@@ -2,6 +2,7 @@ package exported
 
 import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	authexported "github.com/cosmos/cosmos-sdk/x/auth/exported"
 )
 
 // GenesisBalance defines a genesis balance interface that allows for account
@@ -10,3 +11,26 @@ type GenesisBalance interface {
 	GetAddress() sdk.AccAddress
 	GetCoins() sdk.Coins
 }
+
+// ModuleAccountI defines an account interface for modules that hold tokens in
+// an escrow.
+type ModuleAccountI interface {
+	authexported.Account
+
+	GetName() string
+	GetPermissions() []string
+	HasPermission(string) bool
+}
+
+// SupplyI defines an inflationary supply interface for modules that handle
+// token supply.
+type SupplyI interface {
+	GetTotal() sdk.Coins
+	SetTotal(total sdk.Coins)
+
+	Inflate(amount sdk.Coins)
+	Deflate(amount sdk.Coins)
+
+	String() string
+	ValidateBasic() error
+}

x/bank/genesis.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/x/bank/types"
 )
 
 // InitGenesis initializes the bank module's state from a given genesis state.
@@ -20,6 +21,21 @@ func InitGenesis(ctx sdk.Context, keeper Keeper, genState GenesisState) {
 			panic(fmt.Errorf("error on setting balances %w", err))
 		}
 	}
+
+	if data.Supply.Empty() {
+		var totalSupply sdk.Coins
+
+		keeper.IterateAllBalances(ctx,
+			func(_ sdk.AccAddress, balance sdk.Coin) (stop bool) {
+				totalSupply = totalSupply.Add(balance)
+				return false
+			},
+		)
+
+		data.Supply = totalSupply
+	}
+
+	keeper.SetSupply(ctx, NewSupply(data.Supply))
 }
 
 // ExportGenesis returns the bank module's genesis state.
@@ -45,5 +61,11 @@ func ExportGenesis(ctx sdk.Context, keeper Keeper) GenesisState {
 		})
 	}
 
-	return NewGenesisState(keeper.GetSendEnabled(ctx), balances)
+	return NewGenesisState(keeper.GetSendEnabled(ctx), balances, keeper.GetSupply(ctx).GetTotal())
+}
+
+// ValidateGenesis performs basic validation of supply genesis data returning an
+// error for any failed validation criteria.
+func ValidateGenesis(data GenesisState) error {
+	return types.NewSupply(data.Supply).ValidateBasic()
 }

x/bank/keeper/invariants.go

@@ -8,20 +8,27 @@ import (
 )
 
 // RegisterInvariants registers the bank module invariants
-func RegisterInvariants(ir sdk.InvariantRegistry, bk ViewKeeper) {
-	ir.RegisterRoute(types.ModuleName, "nonnegative-outstanding",
-		NonnegativeBalanceInvariant(bk))
+func RegisterInvariants(ir sdk.InvariantRegistry, k Keeper) {
+	ir.RegisterRoute(types.ModuleName, "nonnegative-outstanding", NonnegativeBalanceInvariant(k))
+	ir.RegisterRoute(types.ModuleName, "total-supply", TotalSupply(k))
+}
+
+// AllInvariants runs all invariants of the X/bank module.
+func AllInvariants(k Keeper) sdk.Invariant {
+	return func(ctx sdk.Context) (string, bool) {
+		return TotalSupply(k)(ctx)
+	}
 }
 
 // NonnegativeBalanceInvariant checks that all accounts in the application have non-negative balances
-func NonnegativeBalanceInvariant(bk ViewKeeper) sdk.Invariant {
+func NonnegativeBalanceInvariant(k ViewKeeper) sdk.Invariant {
 	return func(ctx sdk.Context) (string, bool) {
 		var (
 			msg   string
 			count int
 		)
 
-		bk.IterateAllBalances(ctx, func(addr sdk.AccAddress, balance sdk.Coin) bool {
+		k.IterateAllBalances(ctx, func(addr sdk.AccAddress, balance sdk.Coin) bool {
 			if balance.IsNegative() {
 				count++
 				msg += fmt.Sprintf("\t%s has a negative balance of %s\n", addr, balance)
@@ -38,3 +45,24 @@ func NonnegativeBalanceInvariant(bk ViewKeeper) sdk.Invariant {
 		), broken
 	}
 }
+
+// TotalSupply checks that the total supply reflects all the coins held in accounts
+func TotalSupply(k Keeper) sdk.Invariant {
+	return func(ctx sdk.Context) (string, bool) {
+		var expectedTotal sdk.Coins
+		supply := k.GetSupply(ctx)
+
+		k.IterateAllBalances(ctx, func(_ sdk.AccAddress, balance sdk.Coin) bool {
+			expectedTotal = expectedTotal.Add(balance)
+			return false
+		})
+
+		broken := !expectedTotal.IsEqual(supply.GetTotal())
+
+		return sdk.FormatInvariant(types.ModuleName, "total supply",
+			fmt.Sprintf(
+				"\tsum of accounts coins: %v\n"+
+					"\tsupply.Total:          %v\n",
+				expectedTotal, supply.GetTotal())), broken
+	}
+}