diff --git a/std/codec.go b/std/codec.go
index 5557363f5..95cb3786a 100644
--- a/std/codec.go
+++ b/std/codec.go
@@ -8,14 +8,11 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/auth"
 	authexported "github.com/cosmos/cosmos-sdk/x/auth/exported"
 	"github.com/cosmos/cosmos-sdk/x/auth/vesting"
-	"github.com/cosmos/cosmos-sdk/x/bank"
-	bankexported "github.com/cosmos/cosmos-sdk/x/bank/exported"
 	gov "github.com/cosmos/cosmos-sdk/x/gov/types"
 )
 
 var (
 	_ auth.Codec = (*Codec)(nil)
-	_ bank.Codec = (*Codec)(nil)
 	_ gov.Codec  = (*Codec)(nil)
 )
 
@@ -74,45 +71,6 @@ func (c *Codec) UnmarshalAccountJSON(bz []byte) (authexported.Account, error) {
 	return acc.GetAccount(), nil
 }
 
-// MarshalSupply marshals a SupplyI interface. If the given type implements
-// the Marshaler interface, it is treated as a Proto-defined message and
-// serialized that way. Otherwise, it falls back on the internal Amino codec.
-func (c *Codec) MarshalSupply(supplyI bankexported.SupplyI) ([]byte, error) {
-	supply := &Supply{}
-	if err := supply.SetSupplyI(supplyI); err != nil {
-		return nil, err
-	}
-
-	return c.Marshaler.MarshalBinaryBare(supply)
-}
-
-// UnmarshalSupply returns a SupplyI interface from raw encoded account bytes
-// of a Proto-based SupplyI type. An error is returned upon decoding failure.
-func (c *Codec) UnmarshalSupply(bz []byte) (bankexported.SupplyI, error) {
-	supply := &Supply{}
-	if err := c.Marshaler.UnmarshalBinaryBare(bz, supply); err != nil {
-		return nil, err
-	}
-
-	return supply.GetSupplyI(), nil
-}
-
-// MarshalSupplyJSON JSON encodes a supply object implementing the SupplyI
-// interface.
-func (c *Codec) MarshalSupplyJSON(supply bankexported.SupplyI) ([]byte, error) {
-	return c.Marshaler.MarshalJSON(supply)
-}
-
-// UnmarshalSupplyJSON returns a SupplyI from JSON encoded bytes.
-func (c *Codec) UnmarshalSupplyJSON(bz []byte) (bankexported.SupplyI, error) {
-	supply := &Supply{}
-	if err := c.Marshaler.UnmarshalJSON(bz, supply); err != nil {
-		return nil, err
-	}
-
-	return supply.GetSupplyI(), nil
-}
-
 // MarshalProposal marshals a Proposal. It accepts a Proposal defined by the x/gov
 // module and uses the application-level Proposal type which has the concrete
 // Content implementation to serialize.
diff --git a/std/codec.pb.go b/std/codec.pb.go
index f05db8eed..ba55855d9 100644
--- a/std/codec.pb.go
+++ b/std/codec.pb.go
@@ -10,16 +10,15 @@ import (
 	github_com_cosmos_cosmos_sdk_x_auth_exported "github.com/cosmos/cosmos-sdk/x/auth/exported"
 	types "github.com/cosmos/cosmos-sdk/x/auth/types"
 	types1 "github.com/cosmos/cosmos-sdk/x/auth/vesting/types"
-	github_com_cosmos_cosmos_sdk_x_bank_exported "github.com/cosmos/cosmos-sdk/x/bank/exported"
-	types2 "github.com/cosmos/cosmos-sdk/x/bank/types"
+	types5 "github.com/cosmos/cosmos-sdk/x/bank/types"
 	types6 "github.com/cosmos/cosmos-sdk/x/crisis/types"
-	types5 "github.com/cosmos/cosmos-sdk/x/distribution/types"
+	types4 "github.com/cosmos/cosmos-sdk/x/distribution/types"
 	github_com_cosmos_cosmos_sdk_x_gov_types "github.com/cosmos/cosmos-sdk/x/gov/types"
-	types3 "github.com/cosmos/cosmos-sdk/x/gov/types"
+	types2 "github.com/cosmos/cosmos-sdk/x/gov/types"
 	proposal "github.com/cosmos/cosmos-sdk/x/params/types/proposal"
 	types7 "github.com/cosmos/cosmos-sdk/x/slashing/types"
 	types8 "github.com/cosmos/cosmos-sdk/x/staking/types"
-	types4 "github.com/cosmos/cosmos-sdk/x/upgrade/types"
+	types3 "github.com/cosmos/cosmos-sdk/x/upgrade/types"
 	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
 	_ "github.com/regen-network/cosmos-proto"
@@ -166,86 +165,10 @@ func (*Account) XXX_OneofWrappers() []interface{} {
 	}
 }
 
-// Supply defines the application-level Supply type.
-type Supply struct {
-	// sum defines a set of all acceptable concrete Supply implementations.
-	//
-	// Types that are valid to be assigned to Sum:
-	//	*Supply_Supply
-	Sum isSupply_Sum `protobuf_oneof:"sum"`
-}
-
-func (m *Supply) Reset()         { *m = Supply{} }
-func (m *Supply) String() string { return proto.CompactTextString(m) }
-func (*Supply) ProtoMessage()    {}
-func (*Supply) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ff851c3a98ef46f7, []int{1}
-}
-func (m *Supply) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *Supply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_Supply.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 *Supply) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Supply.Merge(m, src)
-}
-func (m *Supply) XXX_Size() int {
-	return m.Size()
-}
-func (m *Supply) XXX_DiscardUnknown() {
-	xxx_messageInfo_Supply.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Supply proto.InternalMessageInfo
-
-type isSupply_Sum interface {
-	isSupply_Sum()
-	Equal(interface{}) bool
-	MarshalTo([]byte) (int, error)
-	Size() int
-}
-
-type Supply_Supply struct {
-	Supply *types2.Supply `protobuf:"bytes,1,opt,name=supply,proto3,oneof" json:"supply,omitempty"`
-}
-
-func (*Supply_Supply) isSupply_Sum() {}
-
-func (m *Supply) GetSum() isSupply_Sum {
-	if m != nil {
-		return m.Sum
-	}
-	return nil
-}
-
-func (m *Supply) GetSupply() *types2.Supply {
-	if x, ok := m.GetSum().(*Supply_Supply); ok {
-		return x.Supply
-	}
-	return nil
-}
-
-// XXX_OneofWrappers is for the internal use of the proto package.
-func (*Supply) XXX_OneofWrappers() []interface{} {
-	return []interface{}{
-		(*Supply_Supply)(nil),
-	}
-}
-
 // MsgSubmitProposal defines the application-level message type for handling
 // governance proposals.
 type MsgSubmitProposal struct {
-	types3.MsgSubmitProposalBase `protobuf:"bytes,1,opt,name=base,proto3,embedded=base" json:"base"`
+	types2.MsgSubmitProposalBase `protobuf:"bytes,1,opt,name=base,proto3,embedded=base" json:"base"`
 	Content                      *Content `protobuf:"bytes,2,opt,name=content,proto3" json:"content,omitempty"`
 }
 
@@ -253,7 +176,7 @@ func (m *MsgSubmitProposal) Reset()         { *m = MsgSubmitProposal{} }
 func (m *MsgSubmitProposal) String() string { return proto.CompactTextString(m) }
 func (*MsgSubmitProposal) ProtoMessage()    {}
 func (*MsgSubmitProposal) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ff851c3a98ef46f7, []int{2}
+	return fileDescriptor_ff851c3a98ef46f7, []int{1}
 }
 func (m *MsgSubmitProposal) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -285,7 +208,7 @@ var xxx_messageInfo_MsgSubmitProposal proto.InternalMessageInfo
 // Proposal defines the application-level concrete proposal type used in
 // governance proposals.
 type Proposal struct {
-	types3.ProposalBase `protobuf:"bytes,1,opt,name=base,proto3,embedded=base" json:"base"`
+	types2.ProposalBase `protobuf:"bytes,1,opt,name=base,proto3,embedded=base" json:"base"`
 	Content             Content `protobuf:"bytes,2,opt,name=content,proto3" json:"content"`
 }
 
@@ -293,7 +216,7 @@ func (m *Proposal) Reset()         { *m = Proposal{} }
 func (m *Proposal) String() string { return proto.CompactTextString(m) }
 func (*Proposal) ProtoMessage()    {}
 func (*Proposal) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ff851c3a98ef46f7, []int{3}
+	return fileDescriptor_ff851c3a98ef46f7, []int{2}
 }
 func (m *Proposal) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -348,7 +271,7 @@ func (m *Content) Reset()         { *m = Content{} }
 func (m *Content) String() string { return proto.CompactTextString(m) }
 func (*Content) ProtoMessage()    {}
 func (*Content) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ff851c3a98ef46f7, []int{4}
+	return fileDescriptor_ff851c3a98ef46f7, []int{3}
 }
 func (m *Content) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -385,19 +308,19 @@ type isContent_Sum interface {
 }
 
 type Content_Text struct {
-	Text *types3.TextProposal `protobuf:"bytes,1,opt,name=text,proto3,oneof" json:"text,omitempty"`
+	Text *types2.TextProposal `protobuf:"bytes,1,opt,name=text,proto3,oneof" json:"text,omitempty"`
 }
 type Content_ParameterChange struct {
 	ParameterChange *proposal.ParameterChangeProposal `protobuf:"bytes,2,opt,name=parameter_change,json=parameterChange,proto3,oneof" json:"parameter_change,omitempty"`
 }
 type Content_SoftwareUpgrade struct {
-	SoftwareUpgrade *types4.SoftwareUpgradeProposal `protobuf:"bytes,3,opt,name=software_upgrade,json=softwareUpgrade,proto3,oneof" json:"software_upgrade,omitempty"`
+	SoftwareUpgrade *types3.SoftwareUpgradeProposal `protobuf:"bytes,3,opt,name=software_upgrade,json=softwareUpgrade,proto3,oneof" json:"software_upgrade,omitempty"`
 }
 type Content_CancelSoftwareUpgrade struct {
-	CancelSoftwareUpgrade *types4.CancelSoftwareUpgradeProposal `protobuf:"bytes,4,opt,name=cancel_software_upgrade,json=cancelSoftwareUpgrade,proto3,oneof" json:"cancel_software_upgrade,omitempty"`
+	CancelSoftwareUpgrade *types3.CancelSoftwareUpgradeProposal `protobuf:"bytes,4,opt,name=cancel_software_upgrade,json=cancelSoftwareUpgrade,proto3,oneof" json:"cancel_software_upgrade,omitempty"`
 }
 type Content_CommunityPoolSpend struct {
-	CommunityPoolSpend *types5.CommunityPoolSpendProposal `protobuf:"bytes,5,opt,name=community_pool_spend,json=communityPoolSpend,proto3,oneof" json:"community_pool_spend,omitempty"`
+	CommunityPoolSpend *types4.CommunityPoolSpendProposal `protobuf:"bytes,5,opt,name=community_pool_spend,json=communityPoolSpend,proto3,oneof" json:"community_pool_spend,omitempty"`
 }
 
 func (*Content_Text) isContent_Sum()                  {}
@@ -413,7 +336,7 @@ func (m *Content) GetSum() isContent_Sum {
 	return nil
 }
 
-func (m *Content) GetText() *types3.TextProposal {
+func (m *Content) GetText() *types2.TextProposal {
 	if x, ok := m.GetSum().(*Content_Text); ok {
 		return x.Text
 	}
@@ -427,21 +350,21 @@ func (m *Content) GetParameterChange() *proposal.ParameterChangeProposal {
 	return nil
 }
 
-func (m *Content) GetSoftwareUpgrade() *types4.SoftwareUpgradeProposal {
+func (m *Content) GetSoftwareUpgrade() *types3.SoftwareUpgradeProposal {
 	if x, ok := m.GetSum().(*Content_SoftwareUpgrade); ok {
 		return x.SoftwareUpgrade
 	}
 	return nil
 }
 
-func (m *Content) GetCancelSoftwareUpgrade() *types4.CancelSoftwareUpgradeProposal {
+func (m *Content) GetCancelSoftwareUpgrade() *types3.CancelSoftwareUpgradeProposal {
 	if x, ok := m.GetSum().(*Content_CancelSoftwareUpgrade); ok {
 		return x.CancelSoftwareUpgrade
 	}
 	return nil
 }
 
-func (m *Content) GetCommunityPoolSpend() *types5.CommunityPoolSpendProposal {
+func (m *Content) GetCommunityPoolSpend() *types4.CommunityPoolSpendProposal {
 	if x, ok := m.GetSum().(*Content_CommunityPoolSpend); ok {
 		return x.CommunityPoolSpend
 	}
@@ -471,7 +394,7 @@ func (m *Transaction) Reset()         { *m = Transaction{} }
 func (m *Transaction) String() string { return proto.CompactTextString(m) }
 func (*Transaction) ProtoMessage()    {}
 func (*Transaction) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ff851c3a98ef46f7, []int{5}
+	return fileDescriptor_ff851c3a98ef46f7, []int{4}
 }
 func (m *Transaction) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -529,7 +452,7 @@ func (m *Message) Reset()         { *m = Message{} }
 func (m *Message) String() string { return proto.CompactTextString(m) }
 func (*Message) ProtoMessage()    {}
 func (*Message) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ff851c3a98ef46f7, []int{6}
+	return fileDescriptor_ff851c3a98ef46f7, []int{5}
 }
 func (m *Message) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -565,34 +488,34 @@ type isMessage_Sum interface {
 }
 
 type Message_MsgSend struct {
-	MsgSend *types2.MsgSend `protobuf:"bytes,1,opt,name=msg_send,json=msgSend,proto3,oneof" json:"msg_send,omitempty"`
+	MsgSend *types5.MsgSend `protobuf:"bytes,1,opt,name=msg_send,json=msgSend,proto3,oneof" json:"msg_send,omitempty"`
 }
 type Message_MsgMultiSend struct {
-	MsgMultiSend *types2.MsgMultiSend `protobuf:"bytes,2,opt,name=msg_multi_send,json=msgMultiSend,proto3,oneof" json:"msg_multi_send,omitempty"`
+	MsgMultiSend *types5.MsgMultiSend `protobuf:"bytes,2,opt,name=msg_multi_send,json=msgMultiSend,proto3,oneof" json:"msg_multi_send,omitempty"`
 }
 type Message_MsgVerifyInvariant struct {
 	MsgVerifyInvariant *types6.MsgVerifyInvariant `protobuf:"bytes,3,opt,name=msg_verify_invariant,json=msgVerifyInvariant,proto3,oneof" json:"msg_verify_invariant,omitempty"`
 }
 type Message_MsgSetWithdrawAddress struct {
-	MsgSetWithdrawAddress *types5.MsgSetWithdrawAddress `protobuf:"bytes,4,opt,name=msg_set_withdraw_address,json=msgSetWithdrawAddress,proto3,oneof" json:"msg_set_withdraw_address,omitempty"`
+	MsgSetWithdrawAddress *types4.MsgSetWithdrawAddress `protobuf:"bytes,4,opt,name=msg_set_withdraw_address,json=msgSetWithdrawAddress,proto3,oneof" json:"msg_set_withdraw_address,omitempty"`
 }
 type Message_MsgWithdrawDelegatorReward struct {
-	MsgWithdrawDelegatorReward *types5.MsgWithdrawDelegatorReward `protobuf:"bytes,5,opt,name=msg_withdraw_delegator_reward,json=msgWithdrawDelegatorReward,proto3,oneof" json:"msg_withdraw_delegator_reward,omitempty"`
+	MsgWithdrawDelegatorReward *types4.MsgWithdrawDelegatorReward `protobuf:"bytes,5,opt,name=msg_withdraw_delegator_reward,json=msgWithdrawDelegatorReward,proto3,oneof" json:"msg_withdraw_delegator_reward,omitempty"`
 }
 type Message_MsgWithdrawValidatorCommission struct {
-	MsgWithdrawValidatorCommission *types5.MsgWithdrawValidatorCommission `protobuf:"bytes,6,opt,name=msg_withdraw_validator_commission,json=msgWithdrawValidatorCommission,proto3,oneof" json:"msg_withdraw_validator_commission,omitempty"`
+	MsgWithdrawValidatorCommission *types4.MsgWithdrawValidatorCommission `protobuf:"bytes,6,opt,name=msg_withdraw_validator_commission,json=msgWithdrawValidatorCommission,proto3,oneof" json:"msg_withdraw_validator_commission,omitempty"`
 }
 type Message_MsgFundCommunityPool struct {
-	MsgFundCommunityPool *types5.MsgFundCommunityPool `protobuf:"bytes,7,opt,name=msg_fund_community_pool,json=msgFundCommunityPool,proto3,oneof" json:"msg_fund_community_pool,omitempty"`
+	MsgFundCommunityPool *types4.MsgFundCommunityPool `protobuf:"bytes,7,opt,name=msg_fund_community_pool,json=msgFundCommunityPool,proto3,oneof" json:"msg_fund_community_pool,omitempty"`
 }
 type Message_MsgSubmitProposal struct {
 	MsgSubmitProposal *MsgSubmitProposal `protobuf:"bytes,9,opt,name=msg_submit_proposal,json=msgSubmitProposal,proto3,oneof" json:"msg_submit_proposal,omitempty"`
 }
 type Message_MsgVote struct {
-	MsgVote *types3.MsgVote `protobuf:"bytes,10,opt,name=msg_vote,json=msgVote,proto3,oneof" json:"msg_vote,omitempty"`
+	MsgVote *types2.MsgVote `protobuf:"bytes,10,opt,name=msg_vote,json=msgVote,proto3,oneof" json:"msg_vote,omitempty"`
 }
 type Message_MsgDeposit struct {
-	MsgDeposit *types3.MsgDeposit `protobuf:"bytes,11,opt,name=msg_deposit,json=msgDeposit,proto3,oneof" json:"msg_deposit,omitempty"`
+	MsgDeposit *types2.MsgDeposit `protobuf:"bytes,11,opt,name=msg_deposit,json=msgDeposit,proto3,oneof" json:"msg_deposit,omitempty"`
 }
 type Message_MsgUnjail struct {
 	MsgUnjail *types7.MsgUnjail `protobuf:"bytes,12,opt,name=msg_unjail,json=msgUnjail,proto3,oneof" json:"msg_unjail,omitempty"`
@@ -637,14 +560,14 @@ func (m *Message) GetSum() isMessage_Sum {
 	return nil
 }
 
-func (m *Message) GetMsgSend() *types2.MsgSend {
+func (m *Message) GetMsgSend() *types5.MsgSend {
 	if x, ok := m.GetSum().(*Message_MsgSend); ok {
 		return x.MsgSend
 	}
 	return nil
 }
 
-func (m *Message) GetMsgMultiSend() *types2.MsgMultiSend {
+func (m *Message) GetMsgMultiSend() *types5.MsgMultiSend {
 	if x, ok := m.GetSum().(*Message_MsgMultiSend); ok {
 		return x.MsgMultiSend
 	}
@@ -658,28 +581,28 @@ func (m *Message) GetMsgVerifyInvariant() *types6.MsgVerifyInvariant {
 	return nil
 }
 
-func (m *Message) GetMsgSetWithdrawAddress() *types5.MsgSetWithdrawAddress {
+func (m *Message) GetMsgSetWithdrawAddress() *types4.MsgSetWithdrawAddress {
 	if x, ok := m.GetSum().(*Message_MsgSetWithdrawAddress); ok {
 		return x.MsgSetWithdrawAddress
 	}
 	return nil
 }
 
-func (m *Message) GetMsgWithdrawDelegatorReward() *types5.MsgWithdrawDelegatorReward {
+func (m *Message) GetMsgWithdrawDelegatorReward() *types4.MsgWithdrawDelegatorReward {
 	if x, ok := m.GetSum().(*Message_MsgWithdrawDelegatorReward); ok {
 		return x.MsgWithdrawDelegatorReward
 	}
 	return nil
 }
 
-func (m *Message) GetMsgWithdrawValidatorCommission() *types5.MsgWithdrawValidatorCommission {
+func (m *Message) GetMsgWithdrawValidatorCommission() *types4.MsgWithdrawValidatorCommission {
 	if x, ok := m.GetSum().(*Message_MsgWithdrawValidatorCommission); ok {
 		return x.MsgWithdrawValidatorCommission
 	}
 	return nil
 }
 
-func (m *Message) GetMsgFundCommunityPool() *types5.MsgFundCommunityPool {
+func (m *Message) GetMsgFundCommunityPool() *types4.MsgFundCommunityPool {
 	if x, ok := m.GetSum().(*Message_MsgFundCommunityPool); ok {
 		return x.MsgFundCommunityPool
 	}
@@ -693,14 +616,14 @@ func (m *Message) GetMsgSubmitProposal() *MsgSubmitProposal {
 	return nil
 }
 
-func (m *Message) GetMsgVote() *types3.MsgVote {
+func (m *Message) GetMsgVote() *types2.MsgVote {
 	if x, ok := m.GetSum().(*Message_MsgVote); ok {
 		return x.MsgVote
 	}
 	return nil
 }
 
-func (m *Message) GetMsgDeposit() *types3.MsgDeposit {
+func (m *Message) GetMsgDeposit() *types2.MsgDeposit {
 	if x, ok := m.GetSum().(*Message_MsgDeposit); ok {
 		return x.MsgDeposit
 	}
@@ -782,7 +705,7 @@ func (m *SignDoc) Reset()         { *m = SignDoc{} }
 func (m *SignDoc) String() string { return proto.CompactTextString(m) }
 func (*SignDoc) ProtoMessage()    {}
 func (*SignDoc) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ff851c3a98ef46f7, []int{7}
+	return fileDescriptor_ff851c3a98ef46f7, []int{6}
 }
 func (m *SignDoc) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -830,7 +753,7 @@ func (m *StdFee) Reset()         { *m = StdFee{} }
 func (m *StdFee) String() string { return proto.CompactTextString(m) }
 func (*StdFee) ProtoMessage()    {}
 func (*StdFee) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ff851c3a98ef46f7, []int{8}
+	return fileDescriptor_ff851c3a98ef46f7, []int{7}
 }
 func (m *StdFee) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -870,7 +793,7 @@ func (m *StdSignature) Reset()         { *m = StdSignature{} }
 func (m *StdSignature) String() string { return proto.CompactTextString(m) }
 func (*StdSignature) ProtoMessage()    {}
 func (*StdSignature) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ff851c3a98ef46f7, []int{9}
+	return fileDescriptor_ff851c3a98ef46f7, []int{8}
 }
 func (m *StdSignature) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -911,7 +834,7 @@ func (m *StdTxBase) Reset()         { *m = StdTxBase{} }
 func (m *StdTxBase) String() string { return proto.CompactTextString(m) }
 func (*StdTxBase) ProtoMessage()    {}
 func (*StdTxBase) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ff851c3a98ef46f7, []int{10}
+	return fileDescriptor_ff851c3a98ef46f7, []int{9}
 }
 func (m *StdTxBase) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -975,7 +898,7 @@ func (m *StdSignDocBase) Reset()         { *m = StdSignDocBase{} }
 func (m *StdSignDocBase) String() string { return proto.CompactTextString(m) }
 func (*StdSignDocBase) ProtoMessage()    {}
 func (*StdSignDocBase) Descriptor() ([]byte, []int) {
-	return fileDescriptor_ff851c3a98ef46f7, []int{11}
+	return fileDescriptor_ff851c3a98ef46f7, []int{10}
 }
 func (m *StdSignDocBase) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1041,7 +964,6 @@ func (m *StdSignDocBase) GetFee() StdFee {
 
 func init() {
 	proto.RegisterType((*Account)(nil), "cosmos_sdk.std.v1.Account")
-	proto.RegisterType((*Supply)(nil), "cosmos_sdk.std.v1.Supply")
 	proto.RegisterType((*MsgSubmitProposal)(nil), "cosmos_sdk.std.v1.MsgSubmitProposal")
 	proto.RegisterType((*Proposal)(nil), "cosmos_sdk.std.v1.Proposal")
 	proto.RegisterType((*Content)(nil), "cosmos_sdk.std.v1.Content")
@@ -1057,166 +979,109 @@ func init() {
 func init() { proto.RegisterFile("std/codec.proto", fileDescriptor_ff851c3a98ef46f7) }
 
 var fileDescriptor_ff851c3a98ef46f7 = []byte{
-	// 1639 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0x4f, 0x6f, 0x1b, 0xb9,
-	0x15, 0x97, 0x62, 0xc5, 0xb2, 0x69, 0xf9, 0x1f, 0x93, 0xd4, 0x8a, 0xeb, 0x48, 0x8e, 0x52, 0x04,
-	0x69, 0x52, 0x4b, 0x71, 0x92, 0xa6, 0x8d, 0xd0, 0x7f, 0x91, 0x1d, 0x43, 0x6e, 0xeb, 0x36, 0x18,
-	0x27, 0x2e, 0x5a, 0xb4, 0x1d, 0x50, 0x33, 0xf4, 0x98, 0xb5, 0x38, 0x9c, 0x0e, 0x39, 0xb2, 0x54,
-	0xa0, 0xa7, 0x16, 0x45, 0x73, 0x28, 0xd0, 0x6b, 0x0f, 0x05, 0xd2, 0x6b, 0xcf, 0x39, 0xed, 0x27,
-	0x08, 0x72, 0xca, 0x71, 0x4f, 0xde, 0x85, 0x73, 0x59, 0xe4, 0xb4, 0xc8, 0x27, 0x58, 0x90, 0xc3,
-	0x19, 0x8d, 0xa4, 0x91, 0xe2, 0x05, 0xf6, 0x22, 0x90, 0xef, 0xbd, 0xdf, 0xef, 0xbd, 0xe1, 0x7b,
-	0x8f, 0x8f, 0x02, 0x8b, 0x5c, 0xd8, 0x35, 0x8b, 0xd9, 0xd8, 0xaa, 0x7a, 0x3e, 0x13, 0x0c, 0x2e,
-	0x5b, 0x8c, 0x53, 0xc6, 0x4d, 0x6e, 0x1f, 0x57, 0xb9, 0xb0, 0xab, 0x9d, 0xcd, 0xd5, 0x3b, 0xe2,
-	0x88, 0xf8, 0xb6, 0xe9, 0x21, 0x5f, 0xf4, 0x6a, 0xca, 0xaa, 0x16, 0x1a, 0x6d, 0x24, 0x37, 0x21,
-	0x7e, 0xf5, 0xe6, 0xa8, 0xb1, 0xc3, 0x1c, 0xd6, 0x5f, 0x69, 0xbb, 0x65, 0xd1, 0xf3, 0x30, 0xaf,
-	0xa9, 0x5f, 0x2d, 0x2a, 0x76, 0x6b, 0x28, 0x10, 0x47, 0xb5, 0x51, 0xcd, 0xba, 0xd6, 0x74, 0x30,
-	0x17, 0xc4, 0x75, 0x6a, 0xa9, 0xd8, 0x16, 0x72, 0x8f, 0x53, 0x34, 0xab, 0xdd, 0x9a, 0xe5, 0x13,
-	0x4e, 0x78, 0x3a, 0xaf, 0x4d, 0xb8, 0xf0, 0x49, 0x2b, 0x10, 0x84, 0xb9, 0x29, 0x16, 0x2b, 0xdd,
-	0x9a, 0xc3, 0x3a, 0x29, 0x8a, 0xb5, 0x6e, 0x8d, 0xb7, 0x11, 0x3f, 0x4a, 0x0f, 0xe7, 0xdb, 0xdd,
-	0x1a, 0x17, 0xe8, 0x38, 0x5d, 0x79, 0xa3, 0x5b, 0xf3, 0x90, 0x8f, 0x68, 0x14, 0x91, 0xe7, 0x33,
-	0x8f, 0x71, 0xd4, 0x1e, 0x66, 0x08, 0x3c, 0xc7, 0x47, 0x36, 0x1e, 0x65, 0xa8, 0x7c, 0x92, 0x03,
-	0xf9, 0xc7, 0x96, 0xc5, 0x02, 0x57, 0xc0, 0x1d, 0x50, 0x68, 0x21, 0x8e, 0x4d, 0x14, 0xee, 0x8b,
-	0xd9, 0xf5, 0xec, 0xad, 0xb9, 0x7b, 0xd7, 0xab, 0x89, 0x3c, 0x76, 0xab, 0xf2, 0xf4, 0xaa, 0x9d,
-	0xcd, 0x6a, 0x03, 0x71, 0xac, 0x81, 0xcd, 0x8c, 0x31, 0xd7, 0xea, 0x6f, 0x61, 0x07, 0xac, 0x5a,
-	0xcc, 0x15, 0xc4, 0x0d, 0x58, 0xc0, 0x4d, 0x7d, 0xd2, 0x31, 0xeb, 0x05, 0xc5, 0xfa, 0x30, 0x8d,
-	0x35, 0xb4, 0x94, 0xec, 0x5b, 0x31, 0xfe, 0x20, 0x14, 0xf6, 0x5d, 0x15, 0xad, 0x31, 0x3a, 0x48,
-	0xc1, 0x8a, 0x8d, 0xdb, 0xa8, 0x87, 0xed, 0x11, 0xa7, 0x53, 0xca, 0xe9, 0xfd, 0xc9, 0x4e, 0xb7,
-	0x43, 0xf0, 0x88, 0xc7, 0x2b, 0x76, 0x9a, 0x02, 0x7a, 0xa0, 0xe8, 0x61, 0x9f, 0x30, 0x9b, 0x58,
-	0x23, 0xfe, 0x72, 0xca, 0xdf, 0x83, 0xc9, 0xfe, 0x9e, 0x6a, 0xf4, 0x88, 0xc3, 0x6f, 0x79, 0xa9,
-	0x1a, 0xf8, 0x4b, 0xb0, 0x40, 0x99, 0x1d, 0xb4, 0xfb, 0x29, 0xba, 0xa8, 0xfc, 0xdc, 0x48, 0x4f,
-	0xd1, 0x9e, 0xb2, 0xed, 0xd3, 0xce, 0xd3, 0xa4, 0xa0, 0xfe, 0xe8, 0xcd, 0xab, 0x8d, 0xef, 0xdf,
-	0x76, 0x88, 0x38, 0x0a, 0x5a, 0x55, 0x8b, 0x51, 0xdd, 0x7d, 0x51, 0x47, 0x72, 0xfb, 0xb8, 0xa6,
-	0x9b, 0x05, 0x77, 0x3d, 0xe6, 0x0b, 0x6c, 0x57, 0x35, 0xb4, 0x71, 0x11, 0x4c, 0xf1, 0x80, 0x56,
-	0xfe, 0x91, 0x05, 0xd3, 0xfb, 0x81, 0xe7, 0xb5, 0x7b, 0xf0, 0x21, 0x98, 0xe6, 0x6a, 0xa5, 0xab,
-	0x66, 0x6d, 0x30, 0x24, 0xd9, 0x51, 0x32, 0xa4, 0xd0, 0xba, 0x99, 0x31, 0xb4, 0x75, 0xfd, 0xc7,
-	0x5f, 0xbc, 0x2c, 0x67, 0xcf, 0x13, 0x88, 0xea, 0xc9, 0x38, 0x90, 0x90, 0x67, 0x37, 0x0a, 0xe4,
-	0xbf, 0x59, 0xb0, 0xbc, 0xc7, 0x9d, 0xfd, 0xa0, 0x45, 0x89, 0x78, 0xaa, 0x9b, 0x00, 0x36, 0x41,
-	0x4e, 0x96, 0xa5, 0x8e, 0xe8, 0xf6, 0x60, 0x44, 0x0e, 0xeb, 0xa8, 0x33, 0x1a, 0x46, 0xc9, 0xba,
-	0x6e, 0xcc, 0xbc, 0x3e, 0x2d, 0x67, 0xde, 0x9e, 0x96, 0xb3, 0x86, 0x62, 0x80, 0x0f, 0x40, 0x5e,
-	0x56, 0x1d, 0x8e, 0xcb, 0x77, 0xb5, 0x3a, 0x72, 0xb9, 0xa9, 0x9a, 0xc5, 0xae, 0x30, 0x22, 0xd3,
-	0xfa, 0xcc, 0x3f, 0x5f, 0x96, 0x33, 0xf2, 0xfb, 0x2a, 0xff, 0xca, 0x82, 0x99, 0x38, 0xac, 0x9f,
-	0x0e, 0x84, 0x75, 0x3d, 0x35, 0xac, 0x89, 0xd1, 0xd4, 0xbf, 0x46, 0x34, 0x8d, 0x9c, 0x04, 0xf7,
-	0x63, 0xca, 0xa9, 0x78, 0xfe, 0x97, 0x03, 0x79, 0x6d, 0x00, 0x7f, 0x00, 0x72, 0x02, 0x77, 0xc5,
-	0xc4, 0x70, 0x9e, 0xe1, 0x6e, 0x7c, 0x40, 0xcd, 0x8c, 0xa1, 0x00, 0xf0, 0xf7, 0x60, 0x49, 0x5d,
-	0x3e, 0x58, 0x60, 0xdf, 0xb4, 0x8e, 0x90, 0xeb, 0x60, 0x1d, 0x4f, 0x6d, 0x90, 0x24, 0xbc, 0xa2,
-	0xd4, 0x67, 0x45, 0xf6, 0x5b, 0xca, 0x3c, 0x41, 0xb9, 0xe8, 0x0d, 0xaa, 0xe0, 0x1f, 0xc0, 0x12,
-	0x67, 0x87, 0xe2, 0x04, 0xf9, 0xd8, 0xd4, 0xd7, 0x97, 0xee, 0xe2, 0xbb, 0x83, 0xec, 0x5a, 0xa9,
-	0xaa, 0x4b, 0x03, 0x9e, 0x87, 0xa2, 0x24, 0x3d, 0x1f, 0x54, 0x41, 0x0f, 0xac, 0x58, 0xc8, 0xb5,
-	0x70, 0xdb, 0x1c, 0xf1, 0x92, 0x4b, 0xbb, 0xa0, 0x12, 0x5e, 0xb6, 0x14, 0x6e, 0xbc, 0xaf, 0x2b,
-	0x56, 0x9a, 0x01, 0x6c, 0x83, 0xcb, 0x16, 0xa3, 0x34, 0x70, 0x89, 0xe8, 0x99, 0x1e, 0x63, 0x6d,
-	0x93, 0x7b, 0xd8, 0xb5, 0x75, 0x0b, 0xff, 0x70, 0xd0, 0x5d, 0x72, 0x96, 0x84, 0xd9, 0xd4, 0xc8,
-	0xa7, 0x8c, 0xb5, 0xf7, 0x25, 0x2e, 0xe1, 0x10, 0x5a, 0x23, 0xda, 0xfa, 0x23, 0xdd, 0x57, 0x9b,
-	0x1f, 0xeb, 0xab, 0x78, 0x26, 0xc5, 0x15, 0xa3, 0x7b, 0xea, 0x45, 0x16, 0xcc, 0x3d, 0xf3, 0x91,
-	0xcb, 0x91, 0x25, 0xa3, 0x80, 0x3f, 0x19, 0x28, 0xdb, 0xb5, 0x94, 0x92, 0xdb, 0x17, 0xf6, 0xb3,
-	0xae, 0xaa, 0xd8, 0x42, 0x54, 0xb1, 0xef, 0x65, 0xf1, 0x45, 0x3d, 0x94, 0xa3, 0xdc, 0xe1, 0xc5,
-	0x0b, 0xeb, 0x53, 0x63, 0x4a, 0x76, 0x0f, 0x73, 0x8e, 0x1c, 0xac, 0x4b, 0x56, 0x59, 0xd7, 0x73,
-	0xb2, 0x87, 0x2a, 0x67, 0x73, 0x20, 0xaf, 0xb5, 0xb0, 0x0e, 0x66, 0x28, 0x77, 0x4c, 0x2e, 0xcf,
-	0x2e, 0x8c, 0xe5, 0x5a, 0xfa, 0x5d, 0x23, 0x5b, 0x1b, 0xbb, 0x76, 0x33, 0x63, 0xe4, 0x69, 0xb8,
-	0x84, 0x3f, 0x07, 0x0b, 0x12, 0x4b, 0x83, 0xb6, 0x20, 0x21, 0x43, 0x58, 0xb0, 0x95, 0xb1, 0x0c,
-	0x7b, 0xd2, 0x54, 0xd3, 0x14, 0x68, 0x62, 0x0f, 0xff, 0x08, 0x2e, 0x4b, 0xae, 0x0e, 0xf6, 0xc9,
-	0x61, 0xcf, 0x24, 0x6e, 0x07, 0xf9, 0x04, 0xc5, 0xa3, 0x66, 0xe8, 0xb6, 0x09, 0xdf, 0x0d, 0x9a,
-	0xf3, 0x40, 0x41, 0x76, 0x23, 0x84, 0xcc, 0x20, 0x1d, 0x91, 0x42, 0x17, 0x14, 0xc3, 0xef, 0x14,
-	0xe6, 0x09, 0x11, 0x47, 0xb6, 0x8f, 0x4e, 0x4c, 0x64, 0xdb, 0x3e, 0xe6, 0x5c, 0x97, 0xe8, 0xfd,
-	0xc9, 0x35, 0xa3, 0xbe, 0x5f, 0xfc, 0x46, 0x63, 0x1f, 0x87, 0x50, 0x59, 0x9f, 0x34, 0x4d, 0x01,
-	0xff, 0x0a, 0xae, 0x49, 0x7f, 0xb1, 0x2f, 0x1b, 0xb7, 0xb1, 0x83, 0x04, 0xf3, 0x4d, 0x1f, 0x9f,
-	0x20, 0xff, 0x9c, 0x85, 0xba, 0xc7, 0x9d, 0x88, 0x78, 0x3b, 0x22, 0x30, 0x14, 0xbe, 0x99, 0x31,
-	0x56, 0xe9, 0x58, 0x2d, 0x7c, 0x91, 0x05, 0xd7, 0x07, 0xfc, 0x77, 0x50, 0x9b, 0xd8, 0xca, 0xbf,
-	0x2c, 0x6f, 0xc2, 0x39, 0x61, 0x6e, 0x71, 0x5a, 0xc5, 0xf0, 0xa3, 0x73, 0xc7, 0x70, 0x10, 0x91,
-	0x6c, 0xc5, 0x1c, 0xcd, 0x8c, 0x51, 0xa2, 0x13, 0x2d, 0xe0, 0x31, 0x58, 0x91, 0xa1, 0x1c, 0x06,
-	0xae, 0x6d, 0x0e, 0xf6, 0x6c, 0x31, 0xaf, 0x02, 0xb8, 0xf7, 0xd1, 0x00, 0x76, 0x02, 0xd7, 0x1e,
-	0x68, 0xda, 0x66, 0xc6, 0x90, 0xf5, 0x32, 0x22, 0x87, 0x07, 0xe0, 0x92, 0xca, 0xb3, 0x9a, 0x42,
-	0x66, 0xf4, 0x82, 0x2b, 0xce, 0x2a, 0x47, 0xdf, 0x49, 0x6b, 0x93, 0xe1, 0x91, 0xd5, 0xcc, 0x18,
-	0xcb, 0x74, 0x64, 0xfa, 0x3d, 0x0a, 0xfb, 0xa4, 0xc3, 0x04, 0x2e, 0x82, 0xb4, 0x99, 0xdc, 0x9f,
-	0x80, 0x07, 0x4c, 0x60, 0xdd, 0x26, 0x72, 0x09, 0x1b, 0x60, 0x4e, 0x42, 0x6d, 0xec, 0x31, 0x4e,
-	0x44, 0x71, 0x4e, 0xa1, 0xcb, 0xe3, 0xd0, 0xdb, 0xa1, 0x59, 0x33, 0x63, 0x00, 0x1a, 0xef, 0xe0,
-	0x36, 0x90, 0x3b, 0x33, 0x70, 0xff, 0x84, 0x48, 0xbb, 0x58, 0x48, 0x7b, 0xa7, 0x44, 0xaf, 0x5e,
-	0xcd, 0xf3, 0x5c, 0x99, 0x36, 0x33, 0xc6, 0x2c, 0x8d, 0x36, 0xd0, 0x0c, 0x9b, 0xcc, 0xf2, 0x31,
-	0x12, 0xb8, 0x5f, 0x12, 0xc5, 0x79, 0xc5, 0x77, 0x67, 0x88, 0x2f, 0x7c, 0x27, 0x6b, 0xba, 0x2d,
-	0x85, 0x89, 0xd3, 0xab, 0xbb, 0x6c, 0x48, 0x0a, 0x7f, 0x0b, 0xa4, 0xd4, 0xc4, 0x36, 0x11, 0x09,
-	0xfa, 0x05, 0x45, 0xff, 0xdd, 0x49, 0xf4, 0x4f, 0x6c, 0x22, 0x92, 0xe4, 0x4b, 0x74, 0x48, 0x06,
-	0x77, 0x41, 0x21, 0x3c, 0x45, 0x55, 0xe8, 0xb8, 0xb8, 0x38, 0x9a, 0xd1, 0x61, 0x52, 0xdd, 0x14,
-	0x32, 0x19, 0x73, 0xb4, 0xbf, 0x8d, 0x8e, 0xa1, 0x85, 0x1d, 0xe2, 0x9a, 0x3e, 0x8e, 0x29, 0x97,
-	0x3e, 0x7e, 0x0c, 0x0d, 0x89, 0x31, 0x62, 0x88, 0x3e, 0x86, 0x21, 0x29, 0xfc, 0x75, 0x78, 0x31,
-	0x06, 0x6e, 0x4c, 0xbd, 0xac, 0xa8, 0x6f, 0x4e, 0xa2, 0x7e, 0xee, 0x26, 0x58, 0xe7, 0x69, 0x52,
-	0x50, 0xbf, 0xfd, 0xe6, 0xd5, 0xc6, 0xcd, 0x89, 0xa3, 0x27, 0x1c, 0x3a, 0x32, 0x42, 0x3d, 0x70,
-	0xfe, 0x9e, 0x05, 0xf9, 0x7d, 0xe2, 0xb8, 0xdb, 0xcc, 0x82, 0x5b, 0xe3, 0xdf, 0x48, 0xfd, 0x61,
-	0xa3, 0x8d, 0xbf, 0xd9, 0x89, 0x53, 0xf9, 0x9b, 0x7c, 0xd4, 0x0a, 0x7b, 0x07, 0xcb, 0x37, 0xc8,
-	0x34, 0xa2, 0xfa, 0xaf, 0x90, 0xa4, 0xb8, 0x94, 0xa4, 0x50, 0x53, 0x99, 0xb8, 0x8d, 0xbb, 0x12,
-	0xfb, 0xff, 0xcf, 0xca, 0xb7, 0xce, 0xf1, 0xb5, 0x12, 0xc0, 0x0d, 0x4d, 0x0a, 0x97, 0xc0, 0x94,
-	0x83, 0xb8, 0x1a, 0x41, 0x39, 0x43, 0x2e, 0x13, 0x2f, 0xc6, 0xbf, 0x80, 0x82, 0xfe, 0x42, 0x24,
-	0x02, 0x1f, 0xc3, 0x1d, 0x90, 0xf7, 0x82, 0x96, 0x79, 0x8c, 0xc3, 0x07, 0x76, 0xa1, 0xb1, 0xf1,
-	0xfe, 0xb4, 0x7c, 0xd9, 0x0b, 0x5a, 0x6d, 0x62, 0x49, 0xe9, 0xf7, 0x18, 0x25, 0x02, 0x53, 0x4f,
-	0xf4, 0x3e, 0x9c, 0x96, 0x97, 0x7b, 0x88, 0xb6, 0xeb, 0x95, 0xbe, 0xb6, 0x62, 0x4c, 0x7b, 0x41,
-	0xeb, 0x17, 0xb8, 0x07, 0xd7, 0xc0, 0x2c, 0x8f, 0x48, 0x95, 0xe7, 0x82, 0xd1, 0x17, 0xe8, 0x69,
-	0xfb, 0x9f, 0x2c, 0x98, 0x8d, 0x67, 0x39, 0xdc, 0x04, 0x53, 0x87, 0x38, 0xca, 0xc4, 0xd5, 0xf4,
-	0x4c, 0xec, 0xe0, 0xe8, 0x0c, 0xa5, 0x2d, 0x7c, 0x02, 0x40, 0xcc, 0x19, 0x1d, 0x7f, 0x79, 0x7c,
-	0x0e, 0x95, 0x9d, 0xc6, 0x27, 0x80, 0x10, 0x82, 0x1c, 0xc5, 0x94, 0xa9, 0x89, 0x3a, 0x6b, 0xa8,
-	0x75, 0xe5, 0xcb, 0x2c, 0x58, 0x18, 0x4c, 0xbd, 0xbc, 0xe8, 0xac, 0x23, 0x44, 0x5c, 0x93, 0x84,
-	0x0f, 0x82, 0xd9, 0x46, 0xe9, 0xec, 0xb4, 0x9c, 0xdf, 0x92, 0xb2, 0xdd, 0xed, 0x0f, 0xa7, 0xe5,
-	0xc5, 0xf0, 0x38, 0x22, 0xa3, 0x8a, 0x91, 0x57, 0xcb, 0x5d, 0x1b, 0xfe, 0x0c, 0x2c, 0xe8, 0x7f,
-	0x52, 0xa6, 0x1b, 0xd0, 0x16, 0xf6, 0xc3, 0x64, 0x34, 0xae, 0x7e, 0x38, 0x2d, 0x5f, 0x09, 0x51,
-	0x83, 0xfa, 0x8a, 0x31, 0xaf, 0x05, 0xbf, 0x52, 0x7b, 0xb8, 0x0a, 0x66, 0x38, 0xfe, 0x73, 0x80,
-	0x5d, 0x2b, 0x7c, 0x9e, 0xe6, 0x8c, 0x78, 0x1f, 0xc7, 0x9f, 0xeb, 0xc7, 0x1f, 0x9d, 0xe6, 0xc5,
-	0xf3, 0x9f, 0x66, 0xa3, 0xfe, 0xfa, 0xac, 0x94, 0x7d, 0x7b, 0x56, 0xca, 0x7e, 0x7e, 0x56, 0xca,
-	0xfe, 0xfb, 0x5d, 0x29, 0xf3, 0xf6, 0x5d, 0x29, 0xf3, 0xe9, 0xbb, 0x52, 0xe6, 0x77, 0xeb, 0x13,
-	0x4b, 0x8e, 0x0b, 0xbb, 0x35, 0xad, 0xfe, 0xe5, 0xdf, 0xff, 0x2a, 0x00, 0x00, 0xff, 0xff, 0x1a,
-	0x12, 0x9f, 0x93, 0x9d, 0x11, 0x00, 0x00,
+	// 1600 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0xcd, 0x6f, 0x1b, 0xc7,
+	0x15, 0x27, 0x2d, 0x5a, 0x94, 0x46, 0xd4, 0xd7, 0xd8, 0xae, 0x68, 0xd5, 0x26, 0x65, 0xba, 0x30,
+	0x5c, 0xbb, 0x22, 0x2d, 0xdb, 0xfd, 0x30, 0x51, 0xb4, 0x35, 0x25, 0x0b, 0x54, 0x5b, 0xb5, 0xc6,
+	0xca, 0x56, 0xd1, 0xa2, 0xed, 0x62, 0xb8, 0x3b, 0x5a, 0x4d, 0xc5, 0xd9, 0xd9, 0xee, 0xcc, 0x52,
+	0x64, 0x81, 0x9e, 0x92, 0x43, 0x7c, 0x08, 0x90, 0x6b, 0x0e, 0x01, 0x9c, 0x6b, 0xce, 0x3e, 0xe5,
+	0x2f, 0x30, 0x7c, 0xf2, 0x31, 0x27, 0x25, 0x90, 0x2f, 0x81, 0x4f, 0x81, 0xff, 0x82, 0x60, 0x66,
+	0x67, 0x97, 0x4b, 0x72, 0x49, 0x2b, 0x40, 0x2e, 0xc2, 0xce, 0x7b, 0xef, 0xf7, 0x7b, 0x8f, 0xef,
+	0x63, 0xde, 0x08, 0x2c, 0x72, 0x61, 0xd7, 0x2c, 0x66, 0x63, 0xab, 0xea, 0xf9, 0x4c, 0x30, 0xb8,
+	0x6c, 0x31, 0x4e, 0x19, 0x37, 0xb9, 0x7d, 0x54, 0xe5, 0xc2, 0xae, 0x76, 0x36, 0x56, 0x6f, 0x8b,
+	0x43, 0xe2, 0xdb, 0xa6, 0x87, 0x7c, 0xd1, 0xab, 0x29, 0xab, 0x5a, 0x68, 0xb4, 0x9e, 0x3c, 0x84,
+	0xf8, 0xd5, 0x1b, 0xa3, 0xc6, 0x0e, 0x73, 0x58, 0xff, 0x4b, 0xdb, 0x2d, 0x8b, 0x9e, 0x87, 0x79,
+	0x4d, 0xfd, 0xd5, 0xa2, 0x62, 0xb7, 0x86, 0x02, 0x71, 0x58, 0x1b, 0xd5, 0xac, 0x69, 0x4d, 0x07,
+	0x73, 0x41, 0x5c, 0xa7, 0x96, 0x8a, 0x6d, 0x21, 0xf7, 0x28, 0x45, 0xb3, 0xda, 0xad, 0x59, 0x3e,
+	0xe1, 0x84, 0xa7, 0xf3, 0xda, 0x84, 0x0b, 0x9f, 0xb4, 0x02, 0x41, 0x98, 0x9b, 0x62, 0xb1, 0xd2,
+	0xad, 0x39, 0xac, 0x93, 0xa2, 0xb8, 0xd2, 0xad, 0xf1, 0x36, 0xe2, 0x87, 0xe9, 0xe1, 0xfc, 0xb4,
+	0x5b, 0xe3, 0x02, 0x1d, 0xa5, 0x2b, 0xaf, 0x77, 0x6b, 0x1e, 0xf2, 0x11, 0x8d, 0x22, 0xf2, 0x7c,
+	0xe6, 0x31, 0x8e, 0xda, 0xc3, 0x0c, 0x81, 0xe7, 0xf8, 0xc8, 0xc6, 0xa3, 0x0c, 0x95, 0x2f, 0x73,
+	0x20, 0xff, 0xd0, 0xb2, 0x58, 0xe0, 0x0a, 0xb8, 0x0d, 0x0a, 0x2d, 0xc4, 0xb1, 0x89, 0xc2, 0x73,
+	0x31, 0xbb, 0x96, 0xbd, 0x39, 0x77, 0xf7, 0x5a, 0x35, 0x51, 0xc7, 0x6e, 0x55, 0x66, 0xaf, 0xda,
+	0xd9, 0xa8, 0x36, 0x10, 0xc7, 0x1a, 0xd8, 0xcc, 0x18, 0x73, 0xad, 0xfe, 0x11, 0x76, 0xc0, 0xaa,
+	0xc5, 0x5c, 0x41, 0xdc, 0x80, 0x05, 0xdc, 0xd4, 0x99, 0x8e, 0x59, 0xcf, 0x29, 0xd6, 0x5f, 0xa5,
+	0xb1, 0x86, 0x96, 0x92, 0x7d, 0x33, 0xc6, 0xef, 0x87, 0xc2, 0xbe, 0xab, 0xa2, 0x35, 0x46, 0x07,
+	0x29, 0x58, 0xb1, 0x71, 0x1b, 0xf5, 0xb0, 0x3d, 0xe2, 0x74, 0x4a, 0x39, 0xbd, 0x37, 0xd9, 0xe9,
+	0x56, 0x08, 0x1e, 0xf1, 0x78, 0xc9, 0x4e, 0x53, 0x40, 0x0f, 0x14, 0x3d, 0xec, 0x13, 0x66, 0x13,
+	0x6b, 0xc4, 0x5f, 0x4e, 0xf9, 0xbb, 0x3f, 0xd9, 0xdf, 0x63, 0x8d, 0x1e, 0x71, 0xf8, 0x13, 0x2f,
+	0x55, 0x03, 0xff, 0x0c, 0x16, 0x28, 0xb3, 0x83, 0x76, 0xbf, 0x44, 0xe7, 0x95, 0x9f, 0xeb, 0xe9,
+	0x25, 0xda, 0x55, 0xb6, 0x7d, 0xda, 0x79, 0x9a, 0x14, 0xd4, 0x1f, 0xbc, 0x7a, 0xb1, 0xfe, 0xcb,
+	0x5b, 0x0e, 0x11, 0x87, 0x41, 0xab, 0x6a, 0x31, 0xaa, 0xa7, 0x2f, 0x9a, 0x48, 0x6e, 0x1f, 0xd5,
+	0xf4, 0xb0, 0xe0, 0xae, 0xc7, 0x7c, 0x81, 0xed, 0xaa, 0x86, 0x36, 0xce, 0x83, 0x29, 0x1e, 0xd0,
+	0xca, 0x67, 0x59, 0xb0, 0xbc, 0xcb, 0x9d, 0xbd, 0xa0, 0x45, 0x89, 0x78, 0xac, 0x7b, 0x0f, 0x36,
+	0x41, 0x4e, 0x76, 0x83, 0x6e, 0x9f, 0x5b, 0x83, 0xb1, 0x39, 0xac, 0xa3, 0x42, 0x1b, 0x46, 0xc9,
+	0x76, 0x6a, 0xcc, 0xbc, 0x3c, 0x29, 0x67, 0x5e, 0x9f, 0x94, 0xb3, 0x86, 0x62, 0x80, 0xf7, 0x41,
+	0x5e, 0x16, 0x1b, 0xc7, 0x5d, 0xb3, 0x5a, 0x1d, 0xb9, 0x53, 0x54, 0xab, 0x60, 0x57, 0x18, 0x91,
+	0x69, 0x7d, 0xe6, 0xa3, 0xe7, 0xe5, 0xcc, 0xb7, 0xcf, 0xcb, 0xd9, 0xca, 0xc7, 0x59, 0x30, 0x13,
+	0x87, 0xf5, 0xfb, 0x81, 0xb0, 0xae, 0xa5, 0x86, 0x35, 0x31, 0x9a, 0xfa, 0x0f, 0x88, 0xa6, 0x91,
+	0x93, 0xe0, 0x7e, 0x4c, 0x39, 0x15, 0xcf, 0xe7, 0x39, 0x90, 0xd7, 0x06, 0xf0, 0xd7, 0x20, 0x27,
+	0x70, 0x57, 0x4c, 0x0c, 0xe7, 0x09, 0xee, 0xc6, 0x09, 0x6a, 0x66, 0x0c, 0x05, 0x80, 0xff, 0x04,
+	0x4b, 0x6a, 0xe6, 0xb1, 0xc0, 0xbe, 0x69, 0x1d, 0x22, 0xd7, 0xc1, 0x3a, 0x9e, 0xda, 0x20, 0x49,
+	0x78, 0x33, 0xa8, 0x9f, 0x15, 0xd9, 0x6f, 0x2a, 0xf3, 0x04, 0xe5, 0xa2, 0x37, 0xa8, 0x82, 0xff,
+	0x02, 0x4b, 0x9c, 0x1d, 0x88, 0x63, 0xe4, 0x63, 0x53, 0xdf, 0x1a, 0x7a, 0x78, 0xee, 0x0c, 0xb2,
+	0x6b, 0xa5, 0xa4, 0xdf, 0xd3, 0x80, 0xa7, 0xa1, 0x28, 0x49, 0xcf, 0x07, 0x55, 0xd0, 0x03, 0x2b,
+	0x16, 0x72, 0x2d, 0xdc, 0x36, 0x47, 0xbc, 0xe4, 0xd2, 0xee, 0x85, 0x84, 0x97, 0x4d, 0x85, 0x1b,
+	0xef, 0xeb, 0x92, 0x95, 0x66, 0x00, 0xdb, 0xe0, 0xa2, 0xc5, 0x28, 0x0d, 0x5c, 0x22, 0x7a, 0xa6,
+	0xc7, 0x58, 0xdb, 0xe4, 0x1e, 0x76, 0x6d, 0x3d, 0x39, 0xbf, 0x19, 0x74, 0x97, 0xbc, 0xc2, 0xc3,
+	0x6a, 0x6a, 0xe4, 0x63, 0xc6, 0xda, 0x7b, 0x12, 0x97, 0x70, 0x08, 0xad, 0x11, 0x6d, 0xfd, 0x81,
+	0xac, 0xf3, 0xab, 0x17, 0xeb, 0x1b, 0xef, 0x9b, 0xab, 0x78, 0x15, 0xc4, 0x1d, 0xa3, 0x67, 0xea,
+	0x59, 0x16, 0xcc, 0x3d, 0xf1, 0x91, 0xcb, 0x91, 0x25, 0xa3, 0x80, 0xbf, 0x1b, 0x68, 0xdb, 0x2b,
+	0x29, 0x2d, 0xb7, 0x27, 0xec, 0x27, 0x5d, 0xd5, 0xb1, 0x85, 0xa8, 0x63, 0xdf, 0xca, 0xe6, 0x8b,
+	0x66, 0x28, 0x47, 0xb9, 0xc3, 0x8b, 0xe7, 0xd6, 0xa6, 0xc6, 0xb4, 0xec, 0x2e, 0xe6, 0x1c, 0x39,
+	0x58, 0xb7, 0xac, 0xb2, 0xae, 0xe7, 0xe4, 0x0c, 0x55, 0x4e, 0xe7, 0x40, 0x5e, 0x6b, 0x61, 0x1d,
+	0xcc, 0x50, 0xee, 0x98, 0x5c, 0xe6, 0x2e, 0x8c, 0xe5, 0xea, 0x60, 0xee, 0xe4, 0xd2, 0x8c, 0x46,
+	0x1b, 0xbb, 0x76, 0x33, 0x63, 0xe4, 0x69, 0xf8, 0x09, 0xff, 0x08, 0x16, 0x24, 0x96, 0x06, 0x6d,
+	0x41, 0x42, 0x86, 0xb0, 0x61, 0x2b, 0x63, 0x19, 0x76, 0xa5, 0xa9, 0xa6, 0x29, 0xd0, 0xc4, 0x19,
+	0xfe, 0x1b, 0x5c, 0x94, 0x5c, 0x1d, 0xec, 0x93, 0x83, 0x9e, 0x49, 0xdc, 0x0e, 0xf2, 0x09, 0x8a,
+	0x6f, 0xf8, 0xa1, 0xdb, 0x26, 0x5c, 0xd7, 0x9a, 0x73, 0x5f, 0x41, 0x76, 0x22, 0x84, 0xac, 0x20,
+	0x1d, 0x91, 0x42, 0x17, 0x14, 0xc3, 0xdf, 0x29, 0xcc, 0x63, 0x22, 0x0e, 0x6d, 0x1f, 0x1d, 0x9b,
+	0xc8, 0xb6, 0x7d, 0xcc, 0xb9, 0x6e, 0xd1, 0x7b, 0x93, 0x7b, 0x46, 0xfd, 0x7e, 0xf1, 0x37, 0x8d,
+	0x7d, 0x18, 0x42, 0x65, 0x7f, 0xd2, 0x34, 0x05, 0xfc, 0x3f, 0xb8, 0x2a, 0xfd, 0xc5, 0xbe, 0x6c,
+	0xdc, 0xc6, 0x0e, 0x12, 0xcc, 0x37, 0x7d, 0x7c, 0x8c, 0xfc, 0x33, 0x36, 0xea, 0x2e, 0x77, 0x22,
+	0xe2, 0xad, 0x88, 0xc0, 0x50, 0xf8, 0x66, 0xc6, 0x58, 0xa5, 0x63, 0xb5, 0xf0, 0x59, 0x16, 0x5c,
+	0x1b, 0xf0, 0xdf, 0x41, 0x6d, 0x62, 0x2b, 0xff, 0xb2, 0xbd, 0x09, 0xe7, 0x84, 0xb9, 0xc5, 0x69,
+	0x15, 0xc3, 0x6f, 0xcf, 0x1c, 0xc3, 0x7e, 0x44, 0xb2, 0x19, 0x73, 0x34, 0x33, 0x46, 0x89, 0x4e,
+	0xb4, 0x80, 0x47, 0x60, 0x45, 0x86, 0x72, 0x10, 0xb8, 0xb6, 0x39, 0x38, 0xb3, 0xc5, 0xbc, 0x0a,
+	0xe0, 0xee, 0x7b, 0x03, 0xd8, 0x0e, 0x5c, 0x7b, 0x60, 0x68, 0x9b, 0x19, 0x43, 0xf6, 0xcb, 0x88,
+	0x1c, 0xee, 0x83, 0x0b, 0xaa, 0xce, 0x6a, 0x0b, 0x99, 0xd1, 0xc3, 0xa9, 0x38, 0xab, 0x1c, 0xfd,
+	0x2c, 0x6d, 0x4c, 0x86, 0x57, 0x56, 0x33, 0x63, 0x2c, 0xd3, 0x91, 0xed, 0xf7, 0x20, 0x9c, 0x93,
+	0x0e, 0x13, 0xb8, 0x08, 0x46, 0x67, 0x36, 0xb9, 0x01, 0xf7, 0x99, 0xc0, 0x7a, 0x4c, 0xe4, 0x27,
+	0x6c, 0x80, 0x39, 0x09, 0xb5, 0xb1, 0xc7, 0x38, 0x11, 0xc5, 0x39, 0x85, 0x2e, 0x8f, 0x43, 0x6f,
+	0x85, 0x66, 0xcd, 0x8c, 0x01, 0x68, 0x7c, 0x82, 0x5b, 0x40, 0x9e, 0xcc, 0xc0, 0xfd, 0x0f, 0x22,
+	0xed, 0x62, 0x21, 0xed, 0x79, 0x10, 0x3d, 0x36, 0x35, 0xcf, 0x53, 0x65, 0xda, 0xcc, 0x18, 0xb3,
+	0x34, 0x3a, 0x40, 0x33, 0x1c, 0x32, 0xcb, 0xc7, 0x48, 0xe0, 0x7e, 0x4b, 0x14, 0xe7, 0x15, 0xdf,
+	0xed, 0x21, 0xbe, 0xf0, 0x79, 0xaa, 0xe9, 0x36, 0x15, 0x26, 0x2e, 0xaf, 0x9e, 0xb2, 0x21, 0x29,
+	0xfc, 0x3b, 0x90, 0x52, 0x13, 0xdb, 0x44, 0x24, 0xe8, 0x17, 0x14, 0xfd, 0xcf, 0x27, 0xd1, 0x3f,
+	0xb2, 0x89, 0x48, 0x92, 0x2f, 0xd1, 0x21, 0x19, 0xdc, 0x01, 0x85, 0x30, 0x8b, 0xaa, 0xd1, 0x71,
+	0x71, 0x71, 0xb4, 0xa2, 0xc3, 0xa4, 0x7a, 0x28, 0x64, 0x31, 0xe6, 0x68, 0xff, 0x18, 0xa5, 0xa1,
+	0x85, 0x1d, 0xe2, 0x9a, 0x3e, 0x8e, 0x29, 0x97, 0xde, 0x9f, 0x86, 0x86, 0xc4, 0x18, 0x31, 0x44,
+	0xa7, 0x61, 0x48, 0x0a, 0xff, 0x1a, 0x5e, 0x8c, 0x81, 0x1b, 0x53, 0x2f, 0x2b, 0xea, 0x1b, 0x93,
+	0xa8, 0x9f, 0xba, 0x09, 0xd6, 0x79, 0x9a, 0x14, 0xd4, 0x6f, 0xbd, 0x7a, 0xb1, 0x7e, 0x63, 0xe2,
+	0xea, 0x09, 0x97, 0x8e, 0x8c, 0x50, 0x2f, 0x9c, 0x0f, 0xb3, 0x20, 0xbf, 0x47, 0x1c, 0x77, 0x8b,
+	0x59, 0x70, 0x73, 0xfc, 0x1b, 0xa9, 0xbf, 0x6c, 0xb4, 0xf1, 0x8f, 0xbb, 0x71, 0x2a, 0x1f, 0x64,
+	0xc1, 0xf4, 0x9e, 0xb0, 0xb7, 0xb1, 0x7c, 0x83, 0x4c, 0x23, 0xaa, 0xff, 0x03, 0x91, 0x14, 0x17,
+	0x92, 0x14, 0x6a, 0x2b, 0x13, 0xb7, 0x71, 0x47, 0x62, 0xbf, 0xf8, 0xba, 0x7c, 0xf3, 0x0c, 0xbf,
+	0x56, 0x02, 0xb8, 0xa1, 0x49, 0xe1, 0x12, 0x98, 0x72, 0x10, 0x57, 0x2b, 0x28, 0x67, 0xc8, 0xcf,
+	0xc4, 0x8b, 0xf1, 0x7f, 0xa0, 0xa0, 0x7f, 0x21, 0x12, 0x81, 0x8f, 0xe1, 0x36, 0xc8, 0x7b, 0x41,
+	0xcb, 0x3c, 0xc2, 0x3d, 0x95, 0x93, 0x42, 0x63, 0xfd, 0xed, 0x49, 0xf9, 0xa2, 0x17, 0xb4, 0xda,
+	0xc4, 0x92, 0xd2, 0x5f, 0x30, 0x4a, 0x04, 0xa6, 0x9e, 0xe8, 0xbd, 0x3b, 0x29, 0x2f, 0xf7, 0x10,
+	0x6d, 0xd7, 0x2b, 0x7d, 0x6d, 0xc5, 0x98, 0xf6, 0x82, 0xd6, 0x9f, 0x70, 0x0f, 0x5e, 0x01, 0xb3,
+	0x3c, 0x22, 0x55, 0x9e, 0x0b, 0x46, 0x5f, 0xa0, 0xb7, 0xed, 0xa7, 0x59, 0x30, 0x1b, 0xef, 0x72,
+	0xb8, 0x01, 0xa6, 0x0e, 0x70, 0x54, 0x89, 0xcb, 0xe9, 0x95, 0xd8, 0xc6, 0x51, 0x0e, 0xa5, 0x2d,
+	0x7c, 0x04, 0x40, 0xcc, 0x19, 0xa5, 0xbf, 0x3c, 0xbe, 0x86, 0xca, 0x4e, 0xe3, 0x13, 0x40, 0x08,
+	0x41, 0x8e, 0x62, 0xca, 0xd4, 0x46, 0x9d, 0x35, 0xd4, 0x77, 0xe5, 0xbb, 0x2c, 0x58, 0x18, 0x2c,
+	0xbd, 0xbc, 0xe8, 0xac, 0x43, 0x44, 0x5c, 0x93, 0x84, 0x0f, 0x82, 0xd9, 0x46, 0xe9, 0xf4, 0xa4,
+	0x9c, 0xdf, 0x94, 0xb2, 0x9d, 0xad, 0x77, 0x27, 0xe5, 0xc5, 0x30, 0x1d, 0x91, 0x51, 0xc5, 0xc8,
+	0xab, 0xcf, 0x1d, 0x1b, 0xfe, 0x01, 0x2c, 0xe8, 0x7f, 0x60, 0x4c, 0x37, 0xa0, 0x2d, 0xec, 0x87,
+	0xc5, 0x68, 0x5c, 0x7e, 0x77, 0x52, 0xbe, 0x14, 0xa2, 0x06, 0xf5, 0x15, 0x63, 0x5e, 0x0b, 0xfe,
+	0xa2, 0xce, 0x70, 0x15, 0xcc, 0x70, 0xfc, 0xdf, 0x00, 0xbb, 0x56, 0xf8, 0x3c, 0xcd, 0x19, 0xf1,
+	0x39, 0x8e, 0x3f, 0xd7, 0x8f, 0x3f, 0xca, 0xe6, 0xf9, 0xb3, 0x67, 0xb3, 0x51, 0x7f, 0x79, 0x5a,
+	0xca, 0xbe, 0x3e, 0x2d, 0x65, 0xbf, 0x39, 0x2d, 0x65, 0x3f, 0x79, 0x53, 0xca, 0xbc, 0x7e, 0x53,
+	0xca, 0x7c, 0xf5, 0xa6, 0x94, 0xf9, 0xc7, 0xda, 0xc4, 0x96, 0xe3, 0xc2, 0x6e, 0x4d, 0xab, 0x7f,
+	0xae, 0xef, 0x7d, 0x1f, 0x00, 0x00, 0xff, 0xff, 0x62, 0xc1, 0x70, 0xf7, 0x14, 0x11, 0x00, 0x00,
 }
 
-func (this *Supply) Equal(that interface{}) bool {
-	if that == nil {
-		return this == nil
-	}
-
-	that1, ok := that.(*Supply)
-	if !ok {
-		that2, ok := that.(Supply)
-		if ok {
-			that1 = &that2
-		} else {
-			return false
-		}
-	}
-	if that1 == nil {
-		return this == nil
-	} else if this == nil {
-		return false
-	}
-	if that1.Sum == nil {
-		if this.Sum != nil {
-			return false
-		}
-	} else if this.Sum == nil {
-		return false
-	} else if !this.Sum.Equal(that1.Sum) {
-		return false
-	}
-	return true
-}
-func (this *Supply_Supply) Equal(that interface{}) bool {
-	if that == nil {
-		return this == nil
-	}
-
-	that1, ok := that.(*Supply_Supply)
-	if !ok {
-		that2, ok := that.(Supply_Supply)
-		if ok {
-			that1 = &that2
-		} else {
-			return false
-		}
-	}
-	if that1 == nil {
-		return this == nil
-	} else if this == nil {
-		return false
-	}
-	if !this.Supply.Equal(that1.Supply) {
-		return false
-	}
-	return true
-}
 func (this *MsgSubmitProposal) Equal(that interface{}) bool {
 	if that == nil {
 		return this == nil
@@ -1497,26 +1362,6 @@ func (this *Account) SetAccount(value github_com_cosmos_cosmos_sdk_x_auth_export
 	return fmt.Errorf("can't encode value of type %T as message Account", value)
 }
 
-func (this *Supply) GetSupplyI() github_com_cosmos_cosmos_sdk_x_bank_exported.SupplyI {
-	if x := this.GetSupply(); x != nil {
-		return x
-	}
-	return nil
-}
-
-func (this *Supply) SetSupplyI(value github_com_cosmos_cosmos_sdk_x_bank_exported.SupplyI) error {
-	if value == nil {
-		this.Sum = nil
-		return nil
-	}
-	switch vt := value.(type) {
-	case *types2.Supply:
-		this.Sum = &Supply_Supply{vt}
-		return nil
-	}
-	return fmt.Errorf("can't encode value of type %T as message Supply", value)
-}
-
 func (this *Content) GetContent() github_com_cosmos_cosmos_sdk_x_gov_types.Content {
 	if x := this.GetText(); x != nil {
 		return x
@@ -1542,19 +1387,19 @@ func (this *Content) SetContent(value github_com_cosmos_cosmos_sdk_x_gov_types.C
 		return nil
 	}
 	switch vt := value.(type) {
-	case *types3.TextProposal:
+	case *types2.TextProposal:
 		this.Sum = &Content_Text{vt}
 		return nil
 	case *proposal.ParameterChangeProposal:
 		this.Sum = &Content_ParameterChange{vt}
 		return nil
-	case *types4.SoftwareUpgradeProposal:
+	case *types3.SoftwareUpgradeProposal:
 		this.Sum = &Content_SoftwareUpgrade{vt}
 		return nil
-	case *types4.CancelSoftwareUpgradeProposal:
+	case *types3.CancelSoftwareUpgradeProposal:
 		this.Sum = &Content_CancelSoftwareUpgrade{vt}
 		return nil
-	case *types5.CommunityPoolSpendProposal:
+	case *types4.CommunityPoolSpendProposal:
 		this.Sum = &Content_CommunityPoolSpend{vt}
 		return nil
 	}
@@ -1619,16 +1464,16 @@ func (this *Message) SetMsg(value github_com_cosmos_cosmos_sdk_types.Msg) error
 		return nil
 	}
 	switch vt := value.(type) {
-	case *types2.MsgSend:
+	case *types5.MsgSend:
 		this.Sum = &Message_MsgSend{vt}
 		return nil
-	case types2.MsgSend:
+	case types5.MsgSend:
 		this.Sum = &Message_MsgSend{&vt}
 		return nil
-	case *types2.MsgMultiSend:
+	case *types5.MsgMultiSend:
 		this.Sum = &Message_MsgMultiSend{vt}
 		return nil
-	case types2.MsgMultiSend:
+	case types5.MsgMultiSend:
 		this.Sum = &Message_MsgMultiSend{&vt}
 		return nil
 	case *types6.MsgVerifyInvariant:
@@ -1637,28 +1482,28 @@ func (this *Message) SetMsg(value github_com_cosmos_cosmos_sdk_types.Msg) error
 	case types6.MsgVerifyInvariant:
 		this.Sum = &Message_MsgVerifyInvariant{&vt}
 		return nil
-	case *types5.MsgSetWithdrawAddress:
+	case *types4.MsgSetWithdrawAddress:
 		this.Sum = &Message_MsgSetWithdrawAddress{vt}
 		return nil
-	case types5.MsgSetWithdrawAddress:
+	case types4.MsgSetWithdrawAddress:
 		this.Sum = &Message_MsgSetWithdrawAddress{&vt}
 		return nil
-	case *types5.MsgWithdrawDelegatorReward:
+	case *types4.MsgWithdrawDelegatorReward:
 		this.Sum = &Message_MsgWithdrawDelegatorReward{vt}
 		return nil
-	case types5.MsgWithdrawDelegatorReward:
+	case types4.MsgWithdrawDelegatorReward:
 		this.Sum = &Message_MsgWithdrawDelegatorReward{&vt}
 		return nil
-	case *types5.MsgWithdrawValidatorCommission:
+	case *types4.MsgWithdrawValidatorCommission:
 		this.Sum = &Message_MsgWithdrawValidatorCommission{vt}
 		return nil
-	case types5.MsgWithdrawValidatorCommission:
+	case types4.MsgWithdrawValidatorCommission:
 		this.Sum = &Message_MsgWithdrawValidatorCommission{&vt}
 		return nil
-	case *types5.MsgFundCommunityPool:
+	case *types4.MsgFundCommunityPool:
 		this.Sum = &Message_MsgFundCommunityPool{vt}
 		return nil
-	case types5.MsgFundCommunityPool:
+	case types4.MsgFundCommunityPool:
 		this.Sum = &Message_MsgFundCommunityPool{&vt}
 		return nil
 	case *MsgSubmitProposal:
@@ -1667,16 +1512,16 @@ func (this *Message) SetMsg(value github_com_cosmos_cosmos_sdk_types.Msg) error
 	case MsgSubmitProposal:
 		this.Sum = &Message_MsgSubmitProposal{&vt}
 		return nil
-	case *types3.MsgVote:
+	case *types2.MsgVote:
 		this.Sum = &Message_MsgVote{vt}
 		return nil
-	case types3.MsgVote:
+	case types2.MsgVote:
 		this.Sum = &Message_MsgVote{&vt}
 		return nil
-	case *types3.MsgDeposit:
+	case *types2.MsgDeposit:
 		this.Sum = &Message_MsgDeposit{vt}
 		return nil
-	case types3.MsgDeposit:
+	case types2.MsgDeposit:
 		this.Sum = &Message_MsgDeposit{&vt}
 		return nil
 	case *types7.MsgUnjail:
@@ -1856,59 +1701,6 @@ func (m *Account_ModuleAccount) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	}
 	return len(dAtA) - i, nil
 }
-func (m *Supply) 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 *Supply) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *Supply) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if m.Sum != nil {
-		{
-			size := m.Sum.Size()
-			i -= size
-			if _, err := m.Sum.MarshalTo(dAtA[i:]); err != nil {
-				return 0, err
-			}
-		}
-	}
-	return len(dAtA) - i, nil
-}
-
-func (m *Supply_Supply) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *Supply_Supply) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	if m.Supply != nil {
-		{
-			size, err := m.Supply.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintCodec(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
 func (m *MsgSubmitProposal) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -2873,30 +2665,6 @@ func (m *Account_ModuleAccount) Size() (n int) {
 	}
 	return n
 }
-func (m *Supply) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if m.Sum != nil {
-		n += m.Sum.Size()
-	}
-	return n
-}
-
-func (m *Supply_Supply) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if m.Supply != nil {
-		l = m.Supply.Size()
-		n += 1 + l + sovCodec(uint64(l))
-	}
-	return n
-}
 func (m *MsgSubmitProposal) Size() (n int) {
 	if m == nil {
 		return 0
@@ -3550,94 +3318,6 @@ func (m *Account) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *Supply) 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 ErrIntOverflowCodec
-			}
-			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: Supply: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: Supply: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Supply", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowCodec
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthCodec
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthCodec
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			v := &types2.Supply{}
-			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			m.Sum = &Supply_Supply{v}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipCodec(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if skippy < 0 {
-				return ErrInvalidLengthCodec
-			}
-			if (iNdEx + skippy) < 0 {
-				return ErrInvalidLengthCodec
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
 func (m *MsgSubmitProposal) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
@@ -3937,7 +3617,7 @@ func (m *Content) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			v := &types3.TextProposal{}
+			v := &types2.TextProposal{}
 			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -4007,7 +3687,7 @@ func (m *Content) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			v := &types4.SoftwareUpgradeProposal{}
+			v := &types3.SoftwareUpgradeProposal{}
 			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -4042,7 +3722,7 @@ func (m *Content) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			v := &types4.CancelSoftwareUpgradeProposal{}
+			v := &types3.CancelSoftwareUpgradeProposal{}
 			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -4077,7 +3757,7 @@ func (m *Content) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			v := &types5.CommunityPoolSpendProposal{}
+			v := &types4.CommunityPoolSpendProposal{}
 			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -4285,7 +3965,7 @@ func (m *Message) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			v := &types2.MsgSend{}
+			v := &types5.MsgSend{}
 			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -4320,7 +4000,7 @@ func (m *Message) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			v := &types2.MsgMultiSend{}
+			v := &types5.MsgMultiSend{}
 			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -4390,7 +4070,7 @@ func (m *Message) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			v := &types5.MsgSetWithdrawAddress{}
+			v := &types4.MsgSetWithdrawAddress{}
 			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -4425,7 +4105,7 @@ func (m *Message) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			v := &types5.MsgWithdrawDelegatorReward{}
+			v := &types4.MsgWithdrawDelegatorReward{}
 			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -4460,7 +4140,7 @@ func (m *Message) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			v := &types5.MsgWithdrawValidatorCommission{}
+			v := &types4.MsgWithdrawValidatorCommission{}
 			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -4495,7 +4175,7 @@ func (m *Message) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			v := &types5.MsgFundCommunityPool{}
+			v := &types4.MsgFundCommunityPool{}
 			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -4565,7 +4245,7 @@ func (m *Message) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			v := &types3.MsgVote{}
+			v := &types2.MsgVote{}
 			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -4600,7 +4280,7 @@ func (m *Message) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			v := &types3.MsgDeposit{}
+			v := &types2.MsgDeposit{}
 			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
diff --git a/std/codec.proto b/std/codec.proto
index 7e8dfe581..0c41b0a49 100644
--- a/std/codec.proto
+++ b/std/codec.proto
@@ -31,17 +31,6 @@ message Account {
   }
 }
 
-// Supply defines the application-level Supply type.
-message Supply {
-  option (gogoproto.equal)             = true;
-  option (cosmos_proto.interface_type) = "*github.com/cosmos/cosmos-sdk/x/bank/exported.SupplyI";
-
-  // sum defines a set of all acceptable concrete Supply implementations.
-  oneof sum {
-    cosmos_sdk.x.bank.v1.Supply supply = 1;
-  }
-}
-
 // MsgSubmitProposal defines the application-level message type for handling
 // governance proposals.
 message MsgSubmitProposal {
diff --git a/third_party/proto/cosmos-proto/cosmos.proto b/third_party/proto/cosmos-proto/cosmos.proto
index a59821d4f..167b17075 100644
--- a/third_party/proto/cosmos-proto/cosmos.proto
+++ b/third_party/proto/cosmos-proto/cosmos.proto
@@ -7,4 +7,10 @@ option go_package = "github.com/regen-network/cosmos-proto";
 
 extend google.protobuf.MessageOptions {
     string interface_type = 93001;
+
+    string implements_interface = 93002;
+}
+
+extend google.protobuf.FieldOptions {
+    string accepts_interface = 93001;
 }
diff --git a/x/bank/alias.go b/x/bank/alias.go
index 314754294..769fdf985 100644
--- a/x/bank/alias.go
+++ b/x/bank/alias.go
@@ -73,5 +73,4 @@ type (
 	Keeper                  = keeper.Keeper
 	GenesisState            = types.GenesisState
 	Supply                  = types.Supply
-	Codec                   = types.Codec
 )
diff --git a/x/bank/keeper/keeper.go b/x/bank/keeper/keeper.go
index 4de3b0a41..413445932 100644
--- a/x/bank/keeper/keeper.go
+++ b/x/bank/keeper/keeper.go
@@ -4,6 +4,8 @@ import (
 	"fmt"
 	"time"
 
+	"github.com/cosmos/cosmos-sdk/codec"
+	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 	"github.com/cosmos/cosmos-sdk/x/auth"
@@ -11,6 +13,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/bank/exported"
 	"github.com/cosmos/cosmos-sdk/x/bank/types"
 	paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
+	"github.com/gogo/protobuf/proto"
 )
 
 var _ Keeper = (*BaseKeeper)(nil)
@@ -33,6 +36,10 @@ type Keeper interface {
 
 	DelegateCoins(ctx sdk.Context, delegatorAddr, moduleAccAddr sdk.AccAddress, amt sdk.Coins) error
 	UndelegateCoins(ctx sdk.Context, moduleAccAddr, delegatorAddr sdk.AccAddress, amt sdk.Coins) error
+	MarshalSupply(supplyI exported.SupplyI) ([]byte, error)
+	UnmarshalSupply(bz []byte) (exported.SupplyI, error)
+	MarshalSupplyJSON(supply exported.SupplyI) ([]byte, error)
+	UnmarshalSupplyJSON(bz []byte) (exported.SupplyI, error)
 }
 
 // BaseKeeper manages transfers between accounts. It implements the Keeper interface.
@@ -40,13 +47,13 @@ type BaseKeeper struct {
 	BaseSendKeeper
 
 	ak         types.AccountKeeper
-	cdc        types.Codec
+	cdc        codec.Marshaler
 	storeKey   sdk.StoreKey
 	paramSpace paramtypes.Subspace
 }
 
 func NewBaseKeeper(
-	cdc types.Codec, storeKey sdk.StoreKey, ak types.AccountKeeper, paramSpace paramtypes.Subspace,
+	cdc codec.Marshaler, storeKey sdk.StoreKey, ak types.AccountKeeper, paramSpace paramtypes.Subspace,
 	blacklistedAddrs map[string]bool,
 ) BaseKeeper {
 
@@ -148,7 +155,7 @@ func (k BaseKeeper) GetSupply(ctx sdk.Context) exported.SupplyI {
 		panic("stored supply should not have been nil")
 	}
 
-	supply, err := k.cdc.UnmarshalSupply(bz)
+	supply, err := k.UnmarshalSupply(bz)
 	if err != nil {
 		panic(err)
 	}
@@ -159,7 +166,7 @@ func (k BaseKeeper) GetSupply(ctx sdk.Context) exported.SupplyI {
 // SetSupply sets the Supply to store
 func (k BaseKeeper) SetSupply(ctx sdk.Context, supply exported.SupplyI) {
 	store := ctx.KVStore(k.storeKey)
-	bz, err := k.cdc.MarshalSupply(supply)
+	bz, err := k.MarshalSupply(supply)
 	if err != nil {
 		panic(err)
 	}
@@ -338,3 +345,53 @@ func (k BaseKeeper) trackUndelegation(ctx sdk.Context, addr sdk.AccAddress, amt
 
 	return nil
 }
+
+// MarshalSupply marshals a Supply interface. If the given type implements
+// the Marshaler interface, it is treated as a Proto-defined message and
+// serialized that way. Otherwise, it falls back on the internal Amino codec.
+func (k BaseKeeper) MarshalSupply(supplyI exported.SupplyI) ([]byte, error) {
+	return codec.MarshalAny(k.cdc, supplyI)
+}
+
+// UnmarshalSupply returns a Supply interface from raw encoded supply
+// bytes of a Proto-based Supply type. An error is returned upon decoding
+// failure.
+func (k BaseKeeper) UnmarshalSupply(bz []byte) (exported.SupplyI, error) {
+	var evi exported.SupplyI
+	if err := codec.UnmarshalAny(k.cdc, &evi, bz); err != nil {
+		return nil, err
+	}
+
+	return evi, nil
+}
+
+// MarshalSupplyJSON JSON encodes a supply object implementing the Supply
+// interface.
+func (k BaseKeeper) MarshalSupplyJSON(supply exported.SupplyI) ([]byte, error) {
+	msg, ok := supply.(proto.Message)
+	if !ok {
+		return nil, fmt.Errorf("cannot proto marshal %T", supply)
+	}
+
+	any, err := codectypes.NewAnyWithValue(msg)
+	if err != nil {
+		return nil, err
+	}
+
+	return k.cdc.MarshalJSON(any)
+}
+
+// UnmarshalSupplyJSON returns a Supply from JSON encoded bytes
+func (k BaseKeeper) UnmarshalSupplyJSON(bz []byte) (exported.SupplyI, error) {
+	var any codectypes.Any
+	if err := k.cdc.UnmarshalJSON(bz, &any); err != nil {
+		return nil, err
+	}
+
+	var supply exported.SupplyI
+	if err := k.cdc.UnpackAny(&any, &supply); err != nil {
+		return nil, err
+	}
+
+	return supply, nil
+}
diff --git a/x/bank/module.go b/x/bank/module.go
index 1cc4b7fa4..721c243e2 100644
--- a/x/bank/module.go
+++ b/x/bank/module.go
@@ -11,6 +11,7 @@ import (
 
 	"github.com/cosmos/cosmos-sdk/client/context"
 	"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"
 	simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
@@ -25,11 +26,12 @@ var (
 	_ module.AppModule           = AppModule{}
 	_ module.AppModuleBasic      = AppModuleBasic{}
 	_ module.AppModuleSimulation = AppModule{}
+	_ module.InterfaceModule     = AppModuleBasic{}
 )
 
 // AppModuleBasic defines the basic application module used by the bank module.
 type AppModuleBasic struct {
-	cdc Codec
+	cdc codec.Marshaler
 }
 
 // Name returns the bank module's name.
@@ -69,6 +71,11 @@ func (AppModuleBasic) GetQueryCmd(cdc *codec.Codec) *cobra.Command {
 	return cli.GetQueryCmd(cdc)
 }
 
+// RegisterInterfaceTypes registers interfaces and implementations of the bank module.
+func (AppModuleBasic) RegisterInterfaceTypes(registry codectypes.InterfaceRegistry) {
+	types.RegisterInterfaces(registry)
+}
+
 //____________________________________________________________________________
 
 // AppModule implements an application module for the bank module.
@@ -80,7 +87,7 @@ type AppModule struct {
 }
 
 // NewAppModule creates a new AppModule object
-func NewAppModule(cdc Codec, keeper Keeper, accountKeeper types.AccountKeeper) AppModule {
+func NewAppModule(cdc codec.Marshaler, keeper Keeper, accountKeeper types.AccountKeeper) AppModule {
 	return AppModule{
 		AppModuleBasic: AppModuleBasic{cdc: cdc},
 		keeper:         keeper,
@@ -156,7 +163,7 @@ func (AppModule) RandomizedParams(r *rand.Rand) []simtypes.ParamChange {
 
 // RegisterStoreDecoder registers a decoder for supply module's types
 func (am AppModule) RegisterStoreDecoder(sdr sdk.StoreDecoderRegistry) {
-	sdr[StoreKey] = simulation.NewDecodeStore(am.cdc)
+	sdr[StoreKey] = simulation.NewDecodeStore(am.keeper)
 }
 
 // WeightedOperations returns the all the gov module operations with their respective weights.
diff --git a/x/bank/simulation/decoder.go b/x/bank/simulation/decoder.go
index 790807c77..9ae45c7a2 100644
--- a/x/bank/simulation/decoder.go
+++ b/x/bank/simulation/decoder.go
@@ -4,14 +4,20 @@ import (
 	"bytes"
 	"fmt"
 
+	"github.com/cosmos/cosmos-sdk/x/bank/exported"
+
 	tmkv "github.com/tendermint/tendermint/libs/kv"
 
 	"github.com/cosmos/cosmos-sdk/x/bank/types"
 )
 
+type SupplyUnmarshaller interface {
+	UnmarshalSupply([]byte) (exported.SupplyI, error)
+}
+
 // NewDecodeStore returns a function closure that unmarshals the KVPair's values
 // to the corresponding types.
-func NewDecodeStore(cdc types.Codec) func(kvA, kvB tmkv.Pair) string {
+func NewDecodeStore(cdc SupplyUnmarshaller) func(kvA, kvB tmkv.Pair) string {
 	return func(kvA, kvB tmkv.Pair) string {
 		switch {
 		case bytes.Equal(kvA.Key[:1], types.SupplyKey):
diff --git a/x/bank/simulation/decoder_test.go b/x/bank/simulation/decoder_test.go
index 4f0e80160..8b3e89c6e 100644
--- a/x/bank/simulation/decoder_test.go
+++ b/x/bank/simulation/decoder_test.go
@@ -14,12 +14,12 @@ import (
 )
 
 func TestDecodeStore(t *testing.T) {
-	cdc, _ := simapp.MakeCodecs()
-	dec := simulation.NewDecodeStore(cdc)
+	app := simapp.Setup(false)
+	dec := simulation.NewDecodeStore(app.BankKeeper)
 
 	totalSupply := types.NewSupply(sdk.NewCoins(sdk.NewInt64Coin(sdk.DefaultBondDenom, 1000)))
 
-	supplyBz, err := cdc.MarshalSupply(totalSupply)
+	supplyBz, err := app.BankKeeper.MarshalSupply(totalSupply)
 	require.NoError(t, err)
 
 	kvPairs := tmkv.Pairs{
diff --git a/x/bank/types/codec.go b/x/bank/types/codec.go
index c8e945aef..74874835e 100644
--- a/x/bank/types/codec.go
+++ b/x/bank/types/codec.go
@@ -3,21 +3,10 @@ package types
 import (
 	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/cosmos/cosmos-sdk/codec/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/bank/exported"
 )
 
-// Codec defines the interface needed to serialize x/bank state. It must
-// be aware of all concrete supply types.
-type Codec interface {
-	codec.Marshaler
-
-	MarshalSupply(supply exported.SupplyI) ([]byte, error)
-	UnmarshalSupply(bz []byte) (exported.SupplyI, error)
-
-	MarshalSupplyJSON(supply exported.SupplyI) ([]byte, error)
-	UnmarshalSupplyJSON(bz []byte) (exported.SupplyI, error)
-}
-
 // RegisterCodec registers the necessary x/bank interfaces and concrete types
 // on the provided Amino codec. These types are used for Amino JSON serialization.
 func RegisterCodec(cdc *codec.Codec) {
@@ -27,6 +16,19 @@ func RegisterCodec(cdc *codec.Codec) {
 	cdc.RegisterConcrete(MsgMultiSend{}, "cosmos-sdk/MsgMultiSend", nil)
 }
 
+func RegisterInterfaces(registry types.InterfaceRegistry) {
+	registry.RegisterImplementations((*sdk.Msg)(nil),
+		&MsgSend{},
+		&MsgMultiSend{},
+	)
+
+	registry.RegisterInterface(
+		"cosmos_sdk.bank.v1.bank",
+		(*exported.SupplyI)(nil),
+		&Supply{},
+	)
+}
+
 var (
 	amino = codec.New()
 
diff --git a/x/bank/types/types.pb.go b/x/bank/types/types.pb.go
index 62a7f1df2..d8f4f2dbb 100644
--- a/x/bank/types/types.pb.go
+++ b/x/bank/types/types.pb.go
@@ -10,6 +10,7 @@ import (
 	types "github.com/cosmos/cosmos-sdk/types"
 	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
+	_ "github.com/regen-network/cosmos-proto"
 	io "io"
 	math "math"
 	math_bits "math/bits"
@@ -295,35 +296,37 @@ func init() {
 func init() { proto.RegisterFile("x/bank/types/types.proto", fileDescriptor_934ff6b24d3432e2) }
 
 var fileDescriptor_934ff6b24d3432e2 = []byte{
-	// 449 bytes of a gzipped FileDescriptorProto
+	// 481 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0xa8, 0xd0, 0x4f, 0x4a,
 	0xcc, 0xcb, 0xd6, 0x2f, 0xa9, 0x2c, 0x48, 0x2d, 0x86, 0x90, 0x7a, 0x05, 0x45, 0xf9, 0x25, 0xf9,
 	0x42, 0x22, 0xc9, 0xf9, 0xc5, 0xb9, 0xf9, 0xc5, 0xf1, 0xc5, 0x29, 0xd9, 0x7a, 0x15, 0x7a, 0x20,
 	0x45, 0x7a, 0x65, 0x86, 0x52, 0x6a, 0x25, 0x19, 0x99, 0x45, 0x29, 0xf1, 0x05, 0x89, 0x45, 0x25,
-	0x95, 0xfa, 0x60, 0x85, 0xfa, 0xe9, 0xf9, 0xe9, 0xf9, 0x08, 0x16, 0x44, 0xb7, 0x94, 0x20, 0x86,
-	0x81, 0x4a, 0x87, 0x98, 0xb8, 0xd8, 0x7d, 0x8b, 0xd3, 0x83, 0x53, 0xf3, 0x52, 0x84, 0xb2, 0xb9,
-	0x78, 0xd2, 0x8a, 0xf2, 0x73, 0xe3, 0x13, 0x53, 0x52, 0x8a, 0x52, 0x8b, 0x8b, 0x25, 0x18, 0x15,
-	0x18, 0x35, 0x78, 0x9c, 0x3c, 0x3e, 0xdd, 0x93, 0x17, 0xae, 0x4c, 0xcc, 0xcd, 0xb1, 0x52, 0x42,
-	0x96, 0x55, 0xfa, 0x75, 0x4f, 0x5e, 0x37, 0x3d, 0xb3, 0x24, 0xa3, 0x34, 0x49, 0x2f, 0x39, 0x3f,
-	0x57, 0x1f, 0xe2, 0x30, 0x28, 0xa5, 0x5b, 0x9c, 0x02, 0x75, 0xbd, 0x9e, 0x63, 0x72, 0xb2, 0x23,
-	0x44, 0x47, 0x10, 0x37, 0x48, 0x3f, 0x94, 0x23, 0x94, 0xca, 0xc5, 0x55, 0x92, 0x0f, 0xb7, 0x8a,
-	0x09, 0x6c, 0x95, 0xdb, 0xa7, 0x7b, 0xf2, 0x82, 0x10, 0xab, 0x10, 0x72, 0x64, 0x58, 0xc4, 0x59,
-	0x92, 0x0f, 0xb3, 0x26, 0x96, 0x8b, 0x2d, 0x31, 0x37, 0xbf, 0x34, 0xaf, 0x44, 0x82, 0x59, 0x81,
-	0x59, 0x83, 0xdb, 0x48, 0x58, 0x0f, 0x29, 0x04, 0xcb, 0x0c, 0xf5, 0x9c, 0xf3, 0x33, 0xf3, 0x9c,
-	0x0c, 0x4e, 0xdc, 0x93, 0x67, 0x58, 0x75, 0x5f, 0x5e, 0x83, 0x08, 0x6b, 0x40, 0x1a, 0x8a, 0x83,
-	0xa0, 0x86, 0x5a, 0xb1, 0xbc, 0x58, 0x20, 0xcf, 0xa8, 0xb4, 0x9d, 0x91, 0x8b, 0xd5, 0x33, 0xaf,
-	0xa0, 0xb4, 0x44, 0xc8, 0x9b, 0x8b, 0x1d, 0x35, 0xf4, 0x0c, 0x49, 0x77, 0x3d, 0xcc, 0x04, 0xa1,
-	0x68, 0x2e, 0xd6, 0x64, 0x90, 0x6d, 0x12, 0x4c, 0xd4, 0x74, 0x3a, 0xc4, 0x4c, 0xa8, 0xcb, 0x77,
-	0x30, 0x72, 0xb1, 0xf9, 0x97, 0x96, 0x0c, 0x45, 0xa7, 0xf7, 0x32, 0x72, 0xf1, 0xf8, 0x16, 0xa7,
-	0xfb, 0x96, 0xe6, 0x94, 0x64, 0x82, 0x93, 0xaf, 0x25, 0x17, 0x5b, 0x26, 0x28, 0x12, 0x40, 0xee,
-	0x07, 0x59, 0x2a, 0xad, 0x87, 0x2d, 0xb3, 0xe8, 0x81, 0x23, 0xca, 0x89, 0x05, 0x64, 0x79, 0x10,
-	0x54, 0x83, 0x90, 0x0d, 0x17, 0x7b, 0x3e, 0x38, 0x14, 0x60, 0x0e, 0x96, 0xc1, 0xae, 0x17, 0x12,
-	0x54, 0x50, 0xcd, 0x30, 0x2d, 0x50, 0xf7, 0x14, 0x73, 0xb1, 0x05, 0x97, 0x16, 0x14, 0xe4, 0x54,
-	0x82, 0x3c, 0x5f, 0x92, 0x5f, 0x92, 0x98, 0x03, 0x75, 0x07, 0xb5, 0x3c, 0x0f, 0x36, 0xd3, 0x8a,
-	0xa7, 0x63, 0x81, 0x3c, 0xc3, 0x8c, 0x05, 0xf2, 0x0c, 0x20, 0x4b, 0x9d, 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, 0x13, 0xaf, 0xc1, 0xc8, 0x05, 0x4c, 0x12, 0x1b,
-	0xb8, 0x28, 0x30, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0xd4, 0x0e, 0x1e, 0x07, 0x77, 0x04, 0x00,
+	0x95, 0xfa, 0x60, 0x85, 0xfa, 0xe9, 0xf9, 0xe9, 0xf9, 0x08, 0x16, 0x44, 0xb7, 0x94, 0x36, 0xa6,
+	0x3a, 0x88, 0x79, 0xba, 0xc8, 0x1c, 0xa8, 0x62, 0x41, 0x0c, 0xdb, 0x95, 0x0e, 0x31, 0x71, 0xb1,
+	0xfb, 0x16, 0xa7, 0x07, 0xa7, 0xe6, 0xa5, 0x08, 0x65, 0x73, 0xf1, 0xa4, 0x15, 0xe5, 0xe7, 0xc6,
+	0x27, 0xa6, 0xa4, 0x14, 0xa5, 0x16, 0x17, 0x4b, 0x30, 0x2a, 0x30, 0x6a, 0xf0, 0x38, 0x79, 0x7c,
+	0xba, 0x27, 0x2f, 0x5c, 0x99, 0x98, 0x9b, 0x63, 0xa5, 0x84, 0x2c, 0xab, 0xf4, 0xeb, 0x9e, 0xbc,
+	0x6e, 0x7a, 0x66, 0x49, 0x46, 0x69, 0x92, 0x5e, 0x72, 0x7e, 0x2e, 0xd4, 0x22, 0x98, 0xe5, 0xc5,
+	0x29, 0x50, 0xaf, 0xea, 0x39, 0x26, 0x27, 0x3b, 0x42, 0x74, 0x04, 0x71, 0x83, 0xf4, 0x43, 0x39,
+	0x42, 0xa9, 0x5c, 0x5c, 0x25, 0xf9, 0x70, 0xab, 0x98, 0xc0, 0x56, 0xb9, 0x7d, 0xba, 0x27, 0x2f,
+	0x08, 0xb1, 0x0a, 0x21, 0x47, 0x86, 0x45, 0x9c, 0x25, 0xf9, 0x30, 0x6b, 0x62, 0xb9, 0xd8, 0x12,
+	0x73, 0xf3, 0x4b, 0xf3, 0x4a, 0x24, 0x98, 0x15, 0x98, 0x35, 0xb8, 0x8d, 0x84, 0xf5, 0x90, 0x82,
+	0xbb, 0xcc, 0x50, 0xcf, 0x39, 0x3f, 0x33, 0xcf, 0xc9, 0xe0, 0xc4, 0x3d, 0x79, 0x86, 0x55, 0xf7,
+	0xe5, 0x35, 0x88, 0xb0, 0x06, 0xa4, 0xa1, 0x38, 0x08, 0x6a, 0xa8, 0x15, 0xcb, 0x8b, 0x05, 0xf2,
+	0x8c, 0x4a, 0xdb, 0x19, 0xb9, 0x58, 0x3d, 0xf3, 0x0a, 0x4a, 0x4b, 0x84, 0xbc, 0xb9, 0xd8, 0x51,
+	0x43, 0xcf, 0x90, 0x74, 0xd7, 0xc3, 0x4c, 0x10, 0x8a, 0xe6, 0x62, 0x4d, 0x06, 0xd9, 0x26, 0xc1,
+	0x44, 0x4d, 0xa7, 0x43, 0xcc, 0x84, 0xba, 0x7c, 0x07, 0x23, 0x17, 0x9b, 0x7f, 0x69, 0xc9, 0x50,
+	0x74, 0x7a, 0x2f, 0x23, 0x17, 0x8f, 0x6f, 0x71, 0xba, 0x6f, 0x69, 0x4e, 0x49, 0x26, 0x38, 0xf9,
+	0x5a, 0x72, 0xb1, 0x65, 0x82, 0x22, 0x01, 0xe4, 0x7e, 0x90, 0xa5, 0xd2, 0x7a, 0xd8, 0x72, 0x96,
+	0x1e, 0x38, 0xa2, 0x9c, 0x58, 0x40, 0x96, 0x07, 0x41, 0x35, 0x08, 0xd9, 0x70, 0xb1, 0xe7, 0x83,
+	0x43, 0x01, 0xe6, 0x60, 0x19, 0xec, 0x7a, 0x21, 0x41, 0x05, 0xd5, 0x0c, 0xd3, 0x02, 0x75, 0xcf,
+	0x1a, 0x46, 0x2e, 0xb6, 0xe0, 0xd2, 0x82, 0x82, 0x9c, 0x4a, 0x90, 0xef, 0x4b, 0xf2, 0x4b, 0x12,
+	0x73, 0xa0, 0x0e, 0xa1, 0x96, 0xef, 0xc1, 0x66, 0x5a, 0xb9, 0x76, 0x2c, 0x90, 0x67, 0x98, 0xb1,
+	0x40, 0x9e, 0x01, 0x64, 0xeb, 0xa5, 0x2d, 0xba, 0xa6, 0x5a, 0x78, 0x4d, 0x80, 0x96, 0x3b, 0xa9,
+	0x15, 0x05, 0xf9, 0x45, 0x25, 0xa9, 0x29, 0x7a, 0x10, 0x27, 0x7a, 0x3a, 0x39, 0x9f, 0x78, 0x24,
+	0xc7, 0x78, 0xe1, 0x91, 0x1c, 0xe3, 0x83, 0x47, 0x72, 0x8c, 0x13, 0x1e, 0xcb, 0x31, 0x5c, 0x78,
+	0x2c, 0xc7, 0x70, 0xe3, 0xb1, 0x1c, 0x43, 0x94, 0x26, 0x31, 0xe6, 0x81, 0x1d, 0x96, 0xc4, 0x06,
+	0x2e, 0x44, 0x8c, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0xc7, 0x5a, 0x2d, 0x41, 0xde, 0x04, 0x00,
 	0x00,
 }
 
diff --git a/x/bank/types/types.proto b/x/bank/types/types.proto
index a1cbd9f61..3cd381bf6 100644
--- a/x/bank/types/types.proto
+++ b/x/bank/types/types.proto
@@ -2,6 +2,7 @@ syntax = "proto3";
 package cosmos_sdk.x.bank.v1;
 
 import "third_party/proto/gogoproto/gogo.proto";
+import "third_party/proto/cosmos-proto/cosmos.proto";
 import "types/types.proto";
 
 option go_package = "github.com/cosmos/cosmos-sdk/x/bank/types";
@@ -54,6 +55,7 @@ message Supply {
   option (gogoproto.equal)            = true;
   option (gogoproto.goproto_getters)  = false;
   option (gogoproto.goproto_stringer) = false;
+  option (cosmos_proto.implements_interface) = "*github.com/cosmos/cosmos-sdk/x/bank/exported.SupplyI";
 
   repeated cosmos_sdk.v1.Coin total = 1
       [(gogoproto.nullable) = false, (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins"];