diff --git a/abci/types/types.pb.go b/abci/types/types.pb.go
index f06a16f15..a60b3a4af 100644
--- a/abci/types/types.pb.go
+++ b/abci/types/types.pb.go
@@ -9,10 +9,9 @@ import (
 	crypto "github.com/cometbft/cometbft/proto/tendermint/crypto"
 	types1 "github.com/cometbft/cometbft/proto/tendermint/types"
 	_ "github.com/cosmos/gogoproto/gogoproto"
-	grpc1 "github.com/cosmos/gogoproto/grpc"
-	proto "github.com/cosmos/gogoproto/proto"
 	_ "github.com/cosmos/gogoproto/types"
-	github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types"
+	proto "github.com/gogo/protobuf/proto"
+	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
 	grpc "google.golang.org/grpc"
 	codes "google.golang.org/grpc/codes"
 	status "google.golang.org/grpc/status"
@@ -1225,6 +1224,8 @@ type RequestPrepareProposal struct {
 	NextValidatorsHash []byte             `protobuf:"bytes,7,opt,name=next_validators_hash,json=nextValidatorsHash,proto3" json:"next_validators_hash,omitempty"`
 	// address of the public key of the validator proposing the block.
 	ProposerAddress []byte `protobuf:"bytes,8,opt,name=proposer_address,json=proposerAddress,proto3" json:"proposer_address,omitempty"`
+	// true/false value if calling PrepareProposal as a non-proposing-node
+	IsNonProposingNode bool `protobuf:"varint,9,opt,name=is_non_proposing_node,json=isNonProposingNode,proto3" json:"is_non_proposing_node,omitempty"`
 }
 
 func (m *RequestPrepareProposal) Reset()         { *m = RequestPrepareProposal{} }
@@ -1316,6 +1317,13 @@ func (m *RequestPrepareProposal) GetProposerAddress() []byte {
 	return nil
 }
 
+func (m *RequestPrepareProposal) GetIsNonProposingNode() bool {
+	if m != nil {
+		return m.IsNonProposingNode
+	}
+	return false
+}
+
 type RequestProcessProposal struct {
 	Txs                [][]byte      `protobuf:"bytes,1,rep,name=txs,proto3" json:"txs,omitempty"`
 	ProposedLastCommit CommitInfo    `protobuf:"bytes,2,opt,name=proposed_last_commit,json=proposedLastCommit,proto3" json:"proposed_last_commit"`
@@ -1420,7 +1428,6 @@ func (m *RequestProcessProposal) GetProposerAddress() []byte {
 
 type Response struct {
 	// Types that are valid to be assigned to Value:
-	//
 	//	*Response_Exception
 	//	*Response_Echo
 	//	*Response_Flush
@@ -3461,196 +3468,198 @@ func init() {
 func init() { proto.RegisterFile("tendermint/abci/types.proto", fileDescriptor_252557cfdd89a31a) }
 
 var fileDescriptor_252557cfdd89a31a = []byte{
-	// 3010 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x5a, 0x3b, 0x73, 0x23, 0xc7,
-	0xf1, 0xc7, 0xfb, 0xd1, 0x78, 0x72, 0x8e, 0xa2, 0x70, 0xd0, 0x89, 0xa4, 0xf6, 0x4a, 0xd2, 0xdd,
-	0x49, 0x22, 0xf5, 0xa7, 0xfe, 0xa7, 0x47, 0xc9, 0xb2, 0x05, 0xe0, 0x70, 0x06, 0x45, 0x8a, 0xa4,
-	0x97, 0xe0, 0xa9, 0xe4, 0xc7, 0xad, 0x16, 0xd8, 0x21, 0xb1, 0x3a, 0x60, 0x77, 0xb5, 0x3b, 0xa0,
-	0x40, 0x85, 0x56, 0xb9, 0xca, 0xa5, 0x72, 0xa0, 0x50, 0x89, 0x02, 0x07, 0xfe, 0x0e, 0x8e, 0x1c,
-	0x39, 0x50, 0xe0, 0x40, 0x81, 0x03, 0x07, 0x2e, 0xd9, 0x25, 0x65, 0xfe, 0x02, 0x0e, 0x1c, 0xd8,
-	0x35, 0x8f, 0x7d, 0x01, 0x58, 0x02, 0x94, 0x5c, 0xae, 0x72, 0x39, 0x9b, 0xe9, 0xed, 0xee, 0x99,
-	0xe9, 0x99, 0xe9, 0xee, 0x5f, 0xef, 0xc0, 0x13, 0x04, 0x1b, 0x1a, 0xb6, 0x47, 0xba, 0x41, 0xb6,
-	0xd5, 0x5e, 0x5f, 0xdf, 0x26, 0x17, 0x16, 0x76, 0xb6, 0x2c, 0xdb, 0x24, 0x26, 0xaa, 0xf8, 0x1f,
-	0xb7, 0xe8, 0xc7, 0xfa, 0x93, 0x01, 0xee, 0xbe, 0x7d, 0x61, 0x11, 0x73, 0xdb, 0xb2, 0x4d, 0xf3,
-	0x94, 0xf3, 0xd7, 0x6f, 0x04, 0x3e, 0x33, 0x3d, 0x41, 0x6d, 0xa1, 0xaf, 0x42, 0xf8, 0x11, 0xbe,
-	0x70, 0xbf, 0x3e, 0x39, 0x23, 0x6b, 0xa9, 0xb6, 0x3a, 0x72, 0x3f, 0x6f, 0x9c, 0x99, 0xe6, 0xd9,
-	0x10, 0x6f, 0xb3, 0x5e, 0x6f, 0x7c, 0xba, 0x4d, 0xf4, 0x11, 0x76, 0x88, 0x3a, 0xb2, 0x04, 0xc3,
-	0xea, 0x99, 0x79, 0x66, 0xb2, 0xe6, 0x36, 0x6d, 0x71, 0xaa, 0xf4, 0xcf, 0x1c, 0x64, 0x65, 0xfc,
-	0xc1, 0x18, 0x3b, 0x04, 0xed, 0x40, 0x0a, 0xf7, 0x07, 0x66, 0x2d, 0xbe, 0x19, 0xbf, 0x55, 0xd8,
-	0xb9, 0xb1, 0x35, 0xb5, 0xb8, 0x2d, 0xc1, 0xd7, 0xee, 0x0f, 0xcc, 0x4e, 0x4c, 0x66, 0xbc, 0xe8,
-	0x2e, 0xa4, 0x4f, 0x87, 0x63, 0x67, 0x50, 0x4b, 0x30, 0xa1, 0x27, 0xa3, 0x84, 0xee, 0x53, 0xa6,
-	0x4e, 0x4c, 0xe6, 0xdc, 0x74, 0x28, 0xdd, 0x38, 0x35, 0x6b, 0xc9, 0xcb, 0x87, 0xda, 0x35, 0x4e,
-	0xd9, 0x50, 0x94, 0x17, 0x35, 0x01, 0x74, 0x43, 0x27, 0x4a, 0x7f, 0xa0, 0xea, 0x46, 0x2d, 0xcd,
-	0x24, 0x9f, 0x8a, 0x96, 0xd4, 0x49, 0x8b, 0x32, 0x76, 0x62, 0x72, 0x5e, 0x77, 0x3b, 0x74, 0xba,
-	0x1f, 0x8c, 0xb1, 0x7d, 0x51, 0xcb, 0x5c, 0x3e, 0xdd, 0x1f, 0x51, 0x26, 0x3a, 0x5d, 0xc6, 0x8d,
-	0xda, 0x50, 0xe8, 0xe1, 0x33, 0xdd, 0x50, 0x7a, 0x43, 0xb3, 0xff, 0xa8, 0x96, 0x65, 0xc2, 0x52,
-	0x94, 0x70, 0x93, 0xb2, 0x36, 0x29, 0x67, 0x27, 0x26, 0x43, 0xcf, 0xeb, 0xa1, 0xef, 0x41, 0xae,
-	0x3f, 0xc0, 0xfd, 0x47, 0x0a, 0x99, 0xd4, 0x72, 0x4c, 0xc7, 0x46, 0x94, 0x8e, 0x16, 0xe5, 0xeb,
-	0x4e, 0x3a, 0x31, 0x39, 0xdb, 0xe7, 0x4d, 0xba, 0x7e, 0x0d, 0x0f, 0xf5, 0x73, 0x6c, 0x53, 0xf9,
-	0xfc, 0xe5, 0xeb, 0xbf, 0xc7, 0x39, 0x99, 0x86, 0xbc, 0xe6, 0x76, 0xd0, 0x0f, 0x20, 0x8f, 0x0d,
-	0x4d, 0x2c, 0x03, 0x98, 0x8a, 0xcd, 0xc8, 0x7d, 0x36, 0x34, 0x77, 0x11, 0x39, 0x2c, 0xda, 0xe8,
-	0x55, 0xc8, 0xf4, 0xcd, 0xd1, 0x48, 0x27, 0xb5, 0x02, 0x93, 0x5e, 0x8f, 0x5c, 0x00, 0xe3, 0xea,
-	0xc4, 0x64, 0xc1, 0x8f, 0x0e, 0xa0, 0x3c, 0xd4, 0x1d, 0xa2, 0x38, 0x86, 0x6a, 0x39, 0x03, 0x93,
-	0x38, 0xb5, 0x22, 0xd3, 0xf0, 0x74, 0x94, 0x86, 0x7d, 0xdd, 0x21, 0xc7, 0x2e, 0x73, 0x27, 0x26,
-	0x97, 0x86, 0x41, 0x02, 0xd5, 0x67, 0x9e, 0x9e, 0x62, 0xdb, 0x53, 0x58, 0x2b, 0x5d, 0xae, 0xef,
-	0x90, 0x72, 0xbb, 0xf2, 0x54, 0x9f, 0x19, 0x24, 0xa0, 0x9f, 0xc0, 0xb5, 0xa1, 0xa9, 0x6a, 0x9e,
-	0x3a, 0xa5, 0x3f, 0x18, 0x1b, 0x8f, 0x6a, 0x65, 0xa6, 0xf4, 0x76, 0xe4, 0x24, 0x4d, 0x55, 0x73,
-	0x55, 0xb4, 0xa8, 0x40, 0x27, 0x26, 0xaf, 0x0c, 0xa7, 0x89, 0xe8, 0x21, 0xac, 0xaa, 0x96, 0x35,
-	0xbc, 0x98, 0xd6, 0x5e, 0x61, 0xda, 0xef, 0x44, 0x69, 0x6f, 0x50, 0x99, 0x69, 0xf5, 0x48, 0x9d,
-	0xa1, 0xa2, 0x2e, 0x54, 0x2d, 0x1b, 0x5b, 0xaa, 0x8d, 0x15, 0xcb, 0x36, 0x2d, 0xd3, 0x51, 0x87,
-	0xb5, 0x2a, 0xd3, 0xfd, 0x6c, 0x94, 0xee, 0x23, 0xce, 0x7f, 0x24, 0xd8, 0x3b, 0x31, 0xb9, 0x62,
-	0x85, 0x49, 0x5c, 0xab, 0xd9, 0xc7, 0x8e, 0xe3, 0x6b, 0x5d, 0x59, 0xa4, 0x95, 0xf1, 0x87, 0xb5,
-	0x86, 0x48, 0xcd, 0x2c, 0xa4, 0xcf, 0xd5, 0xe1, 0x18, 0xbf, 0x95, 0xca, 0xa5, 0xaa, 0x69, 0xe9,
-	0x59, 0x28, 0x04, 0x1c, 0x0b, 0xaa, 0x41, 0x76, 0x84, 0x1d, 0x47, 0x3d, 0xc3, 0xcc, 0x0f, 0xe5,
-	0x65, 0xb7, 0x2b, 0x95, 0xa1, 0x18, 0x74, 0x26, 0xd2, 0xa7, 0x71, 0x4f, 0x92, 0xfa, 0x09, 0x2a,
-	0x79, 0x8e, 0x6d, 0x47, 0x37, 0x0d, 0x57, 0x52, 0x74, 0xd1, 0x4d, 0x28, 0xb1, 0x13, 0xaf, 0xb8,
-	0xdf, 0xa9, 0xb3, 0x4a, 0xc9, 0x45, 0x46, 0x7c, 0x20, 0x98, 0x36, 0xa0, 0x60, 0xed, 0x58, 0x1e,
-	0x4b, 0x92, 0xb1, 0x80, 0xb5, 0x63, 0xb9, 0x0c, 0x4f, 0x41, 0x91, 0xae, 0xd4, 0xe3, 0x48, 0xb1,
-	0x41, 0x0a, 0x94, 0x26, 0x58, 0xa4, 0x3f, 0x24, 0xa0, 0x3a, 0xed, 0x80, 0xd0, 0xab, 0x90, 0xa2,
-	0xbe, 0x58, 0xb8, 0xd5, 0xfa, 0x16, 0x77, 0xd4, 0x5b, 0xae, 0xa3, 0xde, 0xea, 0xba, 0x8e, 0xba,
-	0x99, 0xfb, 0xe2, 0xab, 0x8d, 0xd8, 0xa7, 0x7f, 0xd9, 0x88, 0xcb, 0x4c, 0x02, 0x5d, 0xa7, 0xfe,
-	0x42, 0xd5, 0x0d, 0x45, 0xd7, 0xd8, 0x94, 0xf3, 0xd4, 0x19, 0xa8, 0xba, 0xb1, 0xab, 0xa1, 0x7d,
-	0xa8, 0xf6, 0x4d, 0xc3, 0xc1, 0x86, 0x33, 0x76, 0x14, 0x1e, 0x08, 0x84, 0x33, 0x0d, 0xb9, 0x04,
-	0x1e, 0x5e, 0x5a, 0x2e, 0xe7, 0x11, 0x63, 0x94, 0x2b, 0xfd, 0x30, 0x01, 0xdd, 0x07, 0x38, 0x57,
-	0x87, 0xba, 0xa6, 0x12, 0xd3, 0x76, 0x6a, 0xa9, 0xcd, 0xe4, 0x5c, 0xbf, 0xf0, 0xc0, 0x65, 0x39,
-	0xb1, 0x34, 0x95, 0xe0, 0x66, 0x8a, 0x4e, 0x57, 0x0e, 0x48, 0xa2, 0x67, 0xa0, 0xa2, 0x5a, 0x96,
-	0xe2, 0x10, 0x95, 0x60, 0xa5, 0x77, 0x41, 0xb0, 0xc3, 0xfc, 0x74, 0x51, 0x2e, 0xa9, 0x96, 0x75,
-	0x4c, 0xa9, 0x4d, 0x4a, 0x44, 0x4f, 0x43, 0x99, 0xfa, 0x64, 0x5d, 0x1d, 0x2a, 0x03, 0xac, 0x9f,
-	0x0d, 0x08, 0xf3, 0xc7, 0x49, 0xb9, 0x24, 0xa8, 0x1d, 0x46, 0x94, 0x34, 0x6f, 0xc7, 0x99, 0x3f,
-	0x46, 0x08, 0x52, 0x9a, 0x4a, 0x54, 0x66, 0xc9, 0xa2, 0xcc, 0xda, 0x94, 0x66, 0xa9, 0x64, 0x20,
-	0xec, 0xc3, 0xda, 0x68, 0x0d, 0x32, 0x42, 0x6d, 0x92, 0xa9, 0x15, 0x3d, 0xb4, 0x0a, 0x69, 0xcb,
-	0x36, 0xcf, 0x31, 0xdb, 0xba, 0x9c, 0xcc, 0x3b, 0xd2, 0xc7, 0x09, 0x58, 0x99, 0xf1, 0xdc, 0x54,
-	0xef, 0x40, 0x75, 0x06, 0xee, 0x58, 0xb4, 0x8d, 0x5e, 0xa6, 0x7a, 0x55, 0x0d, 0xdb, 0x22, 0xda,
-	0xd5, 0x66, 0x4d, 0xdd, 0x61, 0xdf, 0x85, 0x69, 0x04, 0x37, 0xda, 0x83, 0xea, 0x50, 0x75, 0x88,
-	0xc2, 0x3d, 0xa1, 0x12, 0x88, 0x7c, 0x4f, 0xcc, 0x18, 0x99, 0xfb, 0x4d, 0x7a, 0xa0, 0x85, 0x92,
-	0x32, 0x15, 0xf5, 0xa9, 0xe8, 0x04, 0x56, 0x7b, 0x17, 0x1f, 0xa9, 0x06, 0xd1, 0x0d, 0xac, 0xcc,
-	0xec, 0xda, 0x6c, 0x28, 0x7d, 0x5b, 0x77, 0x7a, 0x78, 0xa0, 0x9e, 0xeb, 0xa6, 0x3b, 0xad, 0x6b,
-	0x9e, 0xbc, 0xb7, 0xa3, 0x8e, 0x24, 0x43, 0x39, 0x1c, 0x7a, 0x50, 0x19, 0x12, 0x64, 0x22, 0xd6,
-	0x9f, 0x20, 0x13, 0xf4, 0x22, 0xa4, 0xe8, 0x1a, 0xd9, 0xda, 0xcb, 0x73, 0x06, 0x12, 0x72, 0xdd,
-	0x0b, 0x0b, 0xcb, 0x8c, 0x53, 0x92, 0xbc, 0xdb, 0xe0, 0x85, 0xa3, 0x69, 0xad, 0xd2, 0x6d, 0xa8,
-	0x4c, 0xc5, 0x9b, 0xc0, 0xf6, 0xc5, 0x83, 0xdb, 0x27, 0x55, 0xa0, 0x14, 0x0a, 0x2e, 0xd2, 0x1a,
-	0xac, 0xce, 0x8b, 0x15, 0xd2, 0xc0, 0xa3, 0x87, 0x7c, 0x3e, 0xba, 0x0b, 0x39, 0x2f, 0x58, 0xf0,
-	0xdb, 0x78, 0x7d, 0x66, 0x15, 0x2e, 0xb3, 0xec, 0xb1, 0xd2, 0x6b, 0x48, 0x4f, 0x35, 0x3b, 0x0e,
-	0x09, 0x36, 0xf1, 0xac, 0x6a, 0x59, 0x1d, 0xd5, 0x19, 0x48, 0xef, 0x41, 0x2d, 0x2a, 0x10, 0x4c,
-	0x2d, 0x23, 0xe5, 0x9d, 0xc2, 0x35, 0xc8, 0x9c, 0x9a, 0xf6, 0x48, 0x25, 0x4c, 0x59, 0x49, 0x16,
-	0x3d, 0x7a, 0x3a, 0x79, 0x50, 0x48, 0x32, 0x32, 0xef, 0x48, 0x0a, 0x5c, 0x8f, 0x0c, 0x06, 0x54,
-	0x44, 0x37, 0x34, 0xcc, 0xed, 0x59, 0x92, 0x79, 0xc7, 0x57, 0xc4, 0x27, 0xcb, 0x3b, 0x74, 0x58,
-	0x87, 0xad, 0x95, 0xe9, 0xcf, 0xcb, 0xa2, 0x27, 0x7d, 0x96, 0x84, 0xb5, 0xf9, 0x21, 0x01, 0x6d,
-	0x42, 0x71, 0xa4, 0x4e, 0x14, 0x32, 0x11, 0x77, 0x99, 0x6f, 0x07, 0x8c, 0xd4, 0x49, 0x77, 0xc2,
-	0x2f, 0x72, 0x15, 0x92, 0x64, 0xe2, 0xd4, 0x12, 0x9b, 0xc9, 0x5b, 0x45, 0x99, 0x36, 0xd1, 0x09,
-	0xac, 0x0c, 0xcd, 0xbe, 0x3a, 0x54, 0x02, 0x27, 0x5e, 0x1c, 0xf6, 0x9b, 0x33, 0xc6, 0x6e, 0x4f,
-	0x18, 0x45, 0x9b, 0x39, 0xf4, 0x15, 0xa6, 0x63, 0xdf, 0x3b, 0xf9, 0xe8, 0x1e, 0x14, 0x46, 0xfe,
-	0x41, 0xbe, 0xc2, 0x61, 0x0f, 0x8a, 0x05, 0xb6, 0x24, 0x1d, 0x72, 0x0c, 0xae, 0x8b, 0xce, 0x5c,
-	0xd9, 0x45, 0xbf, 0x08, 0xab, 0x06, 0x9e, 0x90, 0xc0, 0x45, 0xe4, 0xe7, 0x24, 0xcb, 0x4c, 0x8f,
-	0xe8, 0x37, 0xff, 0x92, 0xd1, 0x23, 0x83, 0x6e, 0xb3, 0xa0, 0x6a, 0x99, 0x0e, 0xb6, 0x15, 0x55,
-	0xd3, 0x6c, 0xec, 0x38, 0x2c, 0x19, 0x2c, 0xb2, 0x48, 0xc9, 0xe8, 0x0d, 0x4e, 0x96, 0x7e, 0x19,
-	0xdc, 0x9a, 0x50, 0x10, 0x75, 0x0d, 0x1f, 0xf7, 0x0d, 0x7f, 0x0c, 0xab, 0x42, 0x5e, 0x0b, 0xd9,
-	0x3e, 0xb1, 0xac, 0xa3, 0x41, 0xae, 0x78, 0xb4, 0xd9, 0x93, 0xdf, 0xce, 0xec, 0xae, 0x2f, 0x4d,
-	0x05, 0x7c, 0xe9, 0x7f, 0xd9, 0x56, 0xfc, 0x31, 0x0f, 0x39, 0x19, 0x3b, 0x16, 0x0d, 0x9c, 0xa8,
-	0x09, 0x79, 0x3c, 0xe9, 0x63, 0x8b, 0xb8, 0xb9, 0xc6, 0x7c, 0x30, 0xc0, 0xb9, 0xdb, 0x2e, 0x27,
-	0xcd, 0xc4, 0x3d, 0x31, 0xf4, 0x92, 0x00, 0x5b, 0xd1, 0xb8, 0x49, 0x88, 0x07, 0xd1, 0xd6, 0xcb,
-	0x2e, 0xda, 0x4a, 0x46, 0x26, 0xdf, 0x5c, 0x6a, 0x0a, 0x6e, 0xbd, 0x24, 0xe0, 0x56, 0x6a, 0xc1,
-	0x60, 0x21, 0xbc, 0xd5, 0x0a, 0xe1, 0xad, 0xcc, 0x82, 0x65, 0x46, 0x00, 0xae, 0x97, 0x5d, 0xc0,
-	0x95, 0x5d, 0x30, 0xe3, 0x29, 0xc4, 0x75, 0x3f, 0x8c, 0xb8, 0x72, 0x11, 0x0e, 0xc4, 0x95, 0x8e,
-	0x84, 0x5c, 0x6f, 0x04, 0x20, 0x57, 0x3e, 0x12, 0xef, 0x70, 0x25, 0x73, 0x30, 0x57, 0x2b, 0x84,
-	0xb9, 0x60, 0x81, 0x0d, 0x22, 0x40, 0xd7, 0x9b, 0x41, 0xd0, 0x55, 0x88, 0xc4, 0x6d, 0x62, 0xbf,
-	0xe7, 0xa1, 0xae, 0xd7, 0x3c, 0xd4, 0x55, 0x8c, 0x84, 0x8d, 0x62, 0x0d, 0xd3, 0xb0, 0xeb, 0x70,
-	0x06, 0x76, 0x71, 0x98, 0xf4, 0x4c, 0xa4, 0x8a, 0x05, 0xb8, 0xeb, 0x70, 0x06, 0x77, 0x95, 0x17,
-	0x28, 0x5c, 0x00, 0xbc, 0x7e, 0x3a, 0x1f, 0x78, 0x45, 0x43, 0x23, 0x31, 0xcd, 0xe5, 0x90, 0x97,
-	0x12, 0x81, 0xbc, 0x38, 0x3a, 0x7a, 0x2e, 0x52, 0xfd, 0xd2, 0xd0, 0xeb, 0x64, 0x0e, 0xf4, 0xe2,
-	0x20, 0xe9, 0x56, 0xa4, 0xf2, 0x25, 0xb0, 0xd7, 0xc9, 0x1c, 0xec, 0x85, 0x16, 0xaa, 0xbd, 0x0a,
-	0xf8, 0x4a, 0x57, 0x33, 0xd2, 0x6d, 0x9a, 0xfa, 0x4e, 0xf9, 0x29, 0x9a, 0x3f, 0x60, 0xdb, 0x36,
-	0x6d, 0x01, 0xa3, 0x78, 0x47, 0xba, 0x45, 0x93, 0x71, 0xdf, 0x27, 0x5d, 0x02, 0xd4, 0x58, 0x9e,
-	0x16, 0xf0, 0x43, 0xd2, 0x6f, 0xe3, 0xbe, 0x2c, 0xcb, 0x61, 0x83, 0x89, 0x7c, 0x5e, 0x24, 0xf2,
-	0x01, 0xf8, 0x96, 0x08, 0xc3, 0xb7, 0x0d, 0x28, 0xd0, 0xfc, 0x6b, 0x0a, 0x99, 0xa9, 0x96, 0x87,
-	0xcc, 0xee, 0xc0, 0x0a, 0x8b, 0x78, 0x1c, 0xe4, 0x89, 0xb0, 0x92, 0x62, 0x61, 0xa5, 0x42, 0x3f,
-	0xf0, 0x0b, 0xc5, 0xe3, 0xcb, 0x0b, 0x70, 0x2d, 0xc0, 0xeb, 0xe5, 0x75, 0x1c, 0xa6, 0x54, 0x3d,
-	0xee, 0x86, 0x48, 0xf0, 0x7e, 0x1f, 0xf7, 0x2d, 0xe4, 0x43, 0xba, 0x79, 0xe8, 0x2b, 0xfe, 0x6f,
-	0x42, 0x5f, 0x89, 0x6f, 0x8d, 0xbe, 0x82, 0x79, 0x6a, 0x32, 0x9c, 0xa7, 0xfe, 0x3d, 0xee, 0xef,
-	0x89, 0x87, 0xa5, 0xfa, 0xa6, 0x86, 0x45, 0xe6, 0xc8, 0xda, 0x34, 0xa9, 0x18, 0x9a, 0x67, 0x22,
-	0x3f, 0xa4, 0x4d, 0xca, 0xe5, 0x05, 0x8e, 0xbc, 0x88, 0x0b, 0x5e, 0xd2, 0xc9, 0x03, 0xb7, 0x48,
-	0x3a, 0xab, 0x90, 0x7c, 0x84, 0x79, 0x5d, 0xad, 0x28, 0xd3, 0x26, 0xe5, 0x63, 0x47, 0x4d, 0x04,
-	0x60, 0xde, 0x41, 0xaf, 0x42, 0x9e, 0x55, 0x44, 0x15, 0xd3, 0x72, 0x84, 0x5b, 0x0f, 0xe5, 0x26,
-	0xbc, 0xf0, 0xb9, 0x75, 0x44, 0x79, 0x0e, 0x2d, 0x47, 0xce, 0x59, 0xa2, 0x15, 0xc8, 0x18, 0xf2,
-	0xa1, 0x8c, 0xe1, 0x06, 0xe4, 0xe9, 0xec, 0x1d, 0x4b, 0xed, 0x63, 0xe6, 0xa2, 0xf3, 0xb2, 0x4f,
-	0x90, 0x1e, 0x02, 0x9a, 0x0d, 0x12, 0xa8, 0x03, 0x19, 0x7c, 0x8e, 0x0d, 0xc2, 0x33, 0xa8, 0xc2,
-	0xce, 0xda, 0x6c, 0x6a, 0x4a, 0x3f, 0x37, 0x6b, 0xd4, 0xc8, 0x7f, 0xfb, 0x6a, 0xa3, 0xca, 0xb9,
-	0x9f, 0x37, 0x47, 0x3a, 0xc1, 0x23, 0x8b, 0x5c, 0xc8, 0x42, 0x5e, 0xfa, 0x73, 0x82, 0x02, 0x98,
-	0x50, 0x00, 0x99, 0x6b, 0x5b, 0xf7, 0xc8, 0x27, 0x02, 0xd8, 0x75, 0x39, 0x7b, 0xaf, 0x03, 0x9c,
-	0xa9, 0x8e, 0xf2, 0xa1, 0x6a, 0x10, 0xac, 0x09, 0xa3, 0x07, 0x28, 0xa8, 0x0e, 0x39, 0xda, 0x1b,
-	0x3b, 0x58, 0x13, 0x30, 0xda, 0xeb, 0x07, 0xd6, 0x99, 0xfd, 0x6e, 0xeb, 0x0c, 0x5b, 0x39, 0x37,
-	0x65, 0xe5, 0x00, 0xb8, 0xc8, 0x07, 0xc1, 0x05, 0x9d, 0x9b, 0x65, 0xeb, 0xa6, 0xad, 0x93, 0x0b,
-	0xb6, 0x35, 0x49, 0xd9, 0xeb, 0xa3, 0x9b, 0x50, 0x1a, 0xe1, 0x91, 0x65, 0x9a, 0x43, 0x85, 0xbb,
-	0x9b, 0x02, 0x13, 0x2d, 0x0a, 0x62, 0x9b, 0x79, 0x9d, 0x5f, 0x24, 0xfc, 0xfb, 0xe7, 0x83, 0xc8,
-	0xff, 0x39, 0x03, 0x4b, 0xbf, 0x62, 0x95, 0xa5, 0x70, 0x8a, 0x80, 0x8e, 0x61, 0xc5, 0xbb, 0xfe,
-	0xca, 0x98, 0xb9, 0x05, 0xf7, 0x40, 0x2f, 0xeb, 0x3f, 0xaa, 0xe7, 0x61, 0xb2, 0x83, 0xde, 0x85,
-	0xc7, 0xa7, 0x7c, 0x9b, 0xa7, 0x3a, 0xb1, 0xac, 0x8b, 0x7b, 0x2c, 0xec, 0xe2, 0x5c, 0xd5, 0xbe,
-	0xb1, 0x92, 0xdf, 0xf1, 0xd6, 0xed, 0x42, 0x39, 0x9c, 0xf1, 0xcc, 0xdd, 0xfe, 0x9b, 0x50, 0xb2,
-	0x31, 0x51, 0x75, 0x43, 0x09, 0x95, 0x83, 0x8a, 0x9c, 0x28, 0x8a, 0x4c, 0x47, 0xf0, 0xd8, 0xdc,
-	0xcc, 0x07, 0xbd, 0x02, 0x79, 0x3f, 0x69, 0xe2, 0x56, 0xbd, 0xa4, 0x5c, 0xe0, 0xf3, 0x4a, 0xbf,
-	0x8b, 0xfb, 0x2a, 0xc3, 0x05, 0x88, 0x36, 0x64, 0x6c, 0xec, 0x8c, 0x87, 0xbc, 0x24, 0x50, 0xde,
-	0x79, 0x61, 0xb9, 0x9c, 0x89, 0x52, 0xc7, 0x43, 0x22, 0x0b, 0x61, 0xe9, 0x21, 0x64, 0x38, 0x05,
-	0x15, 0x20, 0x7b, 0x72, 0xb0, 0x77, 0x70, 0xf8, 0xce, 0x41, 0x35, 0x86, 0x00, 0x32, 0x8d, 0x56,
-	0xab, 0x7d, 0xd4, 0xad, 0xc6, 0x51, 0x1e, 0xd2, 0x8d, 0xe6, 0xa1, 0xdc, 0xad, 0x26, 0x28, 0x59,
-	0x6e, 0xbf, 0xd5, 0x6e, 0x75, 0xab, 0x49, 0xb4, 0x02, 0x25, 0xde, 0x56, 0xee, 0x1f, 0xca, 0x6f,
-	0x37, 0xba, 0xd5, 0x54, 0x80, 0x74, 0xdc, 0x3e, 0xb8, 0xd7, 0x96, 0xab, 0x69, 0xe9, 0xff, 0xe0,
-	0x7a, 0x64, 0x96, 0xe5, 0x57, 0x17, 0xe2, 0x81, 0xea, 0x82, 0xf4, 0x59, 0x02, 0xea, 0xd1, 0xa9,
-	0x13, 0x7a, 0x6b, 0x6a, 0xe1, 0x3b, 0x57, 0xc8, 0xbb, 0xa6, 0x56, 0x8f, 0x9e, 0x86, 0xb2, 0x8d,
-	0x4f, 0x31, 0xe9, 0x0f, 0x78, 0x2a, 0xc7, 0x43, 0x66, 0x49, 0x2e, 0x09, 0x2a, 0x13, 0x72, 0x38,
-	0xdb, 0xfb, 0xb8, 0x4f, 0x14, 0xee, 0x8b, 0xf8, 0xa1, 0xcb, 0x53, 0x36, 0x4a, 0x3d, 0xe6, 0x44,
-	0xe9, 0xbd, 0x2b, 0xd9, 0x32, 0x0f, 0x69, 0xb9, 0xdd, 0x95, 0xdf, 0xad, 0x26, 0x11, 0x82, 0x32,
-	0x6b, 0x2a, 0xc7, 0x07, 0x8d, 0xa3, 0xe3, 0xce, 0x21, 0xb5, 0xe5, 0x35, 0xa8, 0xb8, 0xb6, 0x74,
-	0x89, 0x69, 0xe9, 0x39, 0x78, 0x3c, 0x22, 0xef, 0x9b, 0x45, 0xf1, 0xd2, 0xaf, 0xe3, 0x41, 0xee,
-	0x30, 0xe6, 0x3f, 0x84, 0x8c, 0x43, 0x54, 0x32, 0x76, 0x84, 0x11, 0x5f, 0x59, 0x36, 0x11, 0xdc,
-	0x72, 0x1b, 0xc7, 0x4c, 0x5c, 0x16, 0x6a, 0xa4, 0xbb, 0x50, 0x0e, 0x7f, 0x89, 0xb6, 0x81, 0x7f,
-	0x88, 0x12, 0xd2, 0xbb, 0x00, 0x81, 0x7a, 0xe4, 0x2a, 0xa4, 0x6d, 0x73, 0x6c, 0x68, 0x6c, 0x52,
-	0x69, 0x99, 0x77, 0xd0, 0x5d, 0x48, 0x9f, 0x9b, 0xdc, 0x67, 0xcc, 0xbf, 0x38, 0x0f, 0x4c, 0x82,
-	0x03, 0xc5, 0x07, 0xce, 0x2d, 0xe9, 0x80, 0x66, 0x6b, 0x42, 0x11, 0x43, 0xbc, 0x11, 0x1e, 0xe2,
-	0xa9, 0xc8, 0xea, 0xd2, 0xfc, 0xa1, 0x3e, 0x82, 0x34, 0xf3, 0x36, 0xd4, 0x73, 0xb0, 0xba, 0xa6,
-	0x48, 0x46, 0x69, 0x1b, 0xfd, 0x0c, 0x40, 0x25, 0xc4, 0xd6, 0x7b, 0x63, 0x7f, 0x80, 0x8d, 0xf9,
-	0xde, 0xaa, 0xe1, 0xf2, 0x35, 0x6f, 0x08, 0xb7, 0xb5, 0xea, 0x8b, 0x06, 0x5c, 0x57, 0x40, 0xa1,
-	0x74, 0x00, 0xe5, 0xb0, 0xac, 0x9b, 0x3e, 0xf1, 0x39, 0x84, 0xd3, 0x27, 0x9e, 0x0d, 0x8b, 0xf4,
-	0xc9, 0x4b, 0xbe, 0x92, 0xbc, 0x84, 0xcd, 0x3a, 0xd2, 0x27, 0x71, 0xc8, 0x75, 0x27, 0xe2, 0x1c,
-	0x47, 0x94, 0x4f, 0x7d, 0xd1, 0x44, 0xb0, 0x58, 0xc8, 0xeb, 0xb1, 0x49, 0xaf, 0xca, 0xfb, 0xa6,
-	0x77, 0x53, 0x53, 0xcb, 0xa2, 0x5d, 0xb7, 0xda, 0x2d, 0xbc, 0xd3, 0xeb, 0x90, 0xf7, 0x62, 0x0d,
-	0xcd, 0xea, 0xdd, 0xca, 0x4a, 0x5c, 0xa4, 0xa4, 0xbc, 0xcb, 0x8a, 0xf1, 0xe6, 0x87, 0xa2, 0x1c,
-	0x99, 0x94, 0x79, 0x47, 0xd2, 0xa0, 0x32, 0x15, 0xa8, 0xd0, 0xeb, 0x90, 0xb5, 0xc6, 0x3d, 0xc5,
-	0x35, 0xcf, 0x54, 0xfd, 0xc9, 0xcd, 0x17, 0xc7, 0xbd, 0xa1, 0xde, 0xdf, 0xc3, 0x17, 0xee, 0x64,
-	0xac, 0x71, 0x6f, 0x8f, 0x5b, 0x91, 0x8f, 0x92, 0x08, 0x8e, 0x72, 0x0e, 0x39, 0xf7, 0x50, 0xa0,
-	0xef, 0x43, 0xde, 0x8b, 0x81, 0xde, 0x3f, 0x9a, 0xc8, 0xe0, 0x29, 0xd4, 0xfb, 0x22, 0x14, 0x7c,
-	0x38, 0xfa, 0x99, 0xe1, 0x56, 0xdd, 0x38, 0xca, 0x4f, 0xb0, 0xdd, 0xa9, 0xf0, 0x0f, 0xfb, 0x2e,
-	0xa8, 0x90, 0x7e, 0x13, 0x87, 0xea, 0xf4, 0xa9, 0xfc, 0x4f, 0x4e, 0x80, 0x3a, 0x45, 0x7a, 0xfa,
-	0x15, 0x4c, 0x27, 0xe1, 0xa1, 0xa9, 0xa2, 0x5c, 0xa2, 0xd4, 0xb6, 0x4b, 0x94, 0x3e, 0x4e, 0x40,
-	0x21, 0x50, 0xd3, 0x43, 0xff, 0x1f, 0xb8, 0x22, 0xe5, 0x39, 0xb9, 0x45, 0x80, 0xd7, 0x2f, 0xff,
-	0x87, 0x17, 0x96, 0xb8, 0xfa, 0xc2, 0xa2, 0x7e, 0xe3, 0xb8, 0x25, 0xc2, 0xd4, 0x95, 0x4b, 0x84,
-	0xcf, 0x03, 0x22, 0x26, 0x51, 0x87, 0xca, 0xb9, 0x49, 0x74, 0xe3, 0x4c, 0xe1, 0x47, 0x83, 0x67,
-	0x7c, 0x55, 0xf6, 0xe5, 0x01, 0xfb, 0x70, 0xc4, 0x4e, 0xc9, 0xcf, 0xe3, 0x90, 0xf3, 0x42, 0xf7,
-	0x55, 0xab, 0xf9, 0x6b, 0x90, 0x11, 0xd1, 0x89, 0x97, 0xf3, 0x45, 0x6f, 0x6e, 0x2d, 0xb4, 0x0e,
-	0xb9, 0x11, 0x26, 0x2a, 0xcb, 0x5f, 0x38, 0x10, 0xf5, 0xfa, 0x77, 0x5e, 0x83, 0x42, 0xe0, 0xc7,
-	0x0a, 0xf5, 0x13, 0x07, 0xed, 0x77, 0xaa, 0xb1, 0x7a, 0xf6, 0x93, 0xcf, 0x37, 0x93, 0x07, 0xf8,
-	0x43, 0x7a, 0xc3, 0xe4, 0x76, 0xab, 0xd3, 0x6e, 0xed, 0x55, 0xe3, 0xf5, 0xc2, 0x27, 0x9f, 0x6f,
-	0x66, 0x65, 0xcc, 0xca, 0x57, 0x77, 0xf6, 0xa0, 0x32, 0xb5, 0x31, 0x61, 0xff, 0x8e, 0xa0, 0x7c,
-	0xef, 0xe4, 0x68, 0x7f, 0xb7, 0xd5, 0xe8, 0xb6, 0x95, 0x07, 0x87, 0xdd, 0x76, 0x35, 0x8e, 0x1e,
-	0x87, 0x6b, 0xfb, 0xbb, 0x3f, 0xec, 0x74, 0x95, 0xd6, 0xfe, 0x6e, 0xfb, 0xa0, 0xab, 0x34, 0xba,
-	0xdd, 0x46, 0x6b, 0xaf, 0x9a, 0xd8, 0xf9, 0x07, 0x40, 0xa5, 0xd1, 0x6c, 0xed, 0xd2, 0xf8, 0xac,
-	0xf7, 0x55, 0x56, 0x28, 0x68, 0x41, 0x8a, 0x95, 0x02, 0x2e, 0x7d, 0x2a, 0x52, 0xbf, 0xbc, 0xb6,
-	0x89, 0xee, 0x43, 0x9a, 0x55, 0x09, 0xd0, 0xe5, 0x6f, 0x47, 0xea, 0x0b, 0x8a, 0x9d, 0x74, 0x32,
-	0xec, 0x3a, 0x5d, 0xfa, 0x98, 0xa4, 0x7e, 0x79, 0xed, 0x13, 0xc9, 0x90, 0xf7, 0x51, 0xc6, 0xe2,
-	0xc7, 0x15, 0xf5, 0x25, 0xbc, 0x23, 0xda, 0x87, 0xac, 0x0b, 0x0c, 0x17, 0x3d, 0xf7, 0xa8, 0x2f,
-	0x2c, 0x4e, 0x52, 0x73, 0x71, 0x00, 0x7f, 0xf9, 0xdb, 0x95, 0xfa, 0x82, 0x4a, 0x2b, 0xda, 0x85,
-	0x8c, 0xc8, 0x9c, 0x17, 0x3c, 0xe1, 0xa8, 0x2f, 0x2a, 0x36, 0x52, 0xa3, 0xf9, 0xa5, 0x91, 0xc5,
-	0x2f, 0x72, 0xea, 0x4b, 0x14, 0x91, 0xd1, 0x09, 0x40, 0x00, 0xae, 0x2f, 0xf1, 0xd4, 0xa6, 0xbe,
-	0x4c, 0x71, 0x18, 0x1d, 0x42, 0xce, 0x43, 0x4f, 0x0b, 0x1f, 0xbe, 0xd4, 0x17, 0x57, 0x69, 0xd1,
-	0x43, 0x28, 0x85, 0x51, 0xc3, 0x72, 0xcf, 0x59, 0xea, 0x4b, 0x96, 0x5f, 0xa9, 0xfe, 0x30, 0x84,
-	0x58, 0xee, 0x79, 0x4b, 0x7d, 0xc9, 0x6a, 0x2c, 0x7a, 0x1f, 0x56, 0x66, 0x53, 0xfc, 0xe5, 0x5f,
-	0xbb, 0xd4, 0xaf, 0x50, 0x9f, 0x45, 0x23, 0x40, 0x73, 0xa0, 0xc1, 0x15, 0x1e, 0xbf, 0xd4, 0xaf,
-	0x52, 0xae, 0x45, 0x1a, 0x54, 0xa6, 0xf3, 0xed, 0x65, 0x1f, 0xc3, 0xd4, 0x97, 0x2e, 0xdd, 0xf2,
-	0x51, 0xc2, 0x79, 0xfa, 0xb2, 0x8f, 0x63, 0xea, 0x4b, 0x57, 0x72, 0x9b, 0x8d, 0x2f, 0xbe, 0x5e,
-	0x8f, 0x7f, 0xf9, 0xf5, 0x7a, 0xfc, 0xaf, 0x5f, 0xaf, 0xc7, 0x3f, 0xfd, 0x66, 0x3d, 0xf6, 0xe5,
-	0x37, 0xeb, 0xb1, 0x3f, 0x7d, 0xb3, 0x1e, 0xfb, 0xf1, 0xb3, 0x67, 0x3a, 0x19, 0x8c, 0x7b, 0x5b,
-	0x7d, 0x73, 0xb4, 0xdd, 0x37, 0x47, 0x98, 0xf4, 0x4e, 0x89, 0xdf, 0xf0, 0x5f, 0x2c, 0xf6, 0x32,
-	0x2c, 0x3e, 0xbe, 0xf4, 0xaf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x89, 0x8f, 0xc4, 0x2a, 0xd1, 0x28,
-	0x00, 0x00,
+	// 3045 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x5a, 0xcd, 0x73, 0x23, 0xc5,
+	0x15, 0xd7, 0xf7, 0xc7, 0xd3, 0xa7, 0x7b, 0xcd, 0xa2, 0x15, 0x8b, 0x6d, 0x66, 0x0b, 0xd8, 0x5d,
+	0xc0, 0x06, 0x93, 0xe5, 0xa3, 0x08, 0x09, 0x96, 0x56, 0x1b, 0x19, 0x1b, 0xdb, 0x19, 0xcb, 0x4b,
+	0x91, 0x8f, 0x1d, 0x46, 0x9a, 0xb6, 0x34, 0xac, 0x34, 0x33, 0xcc, 0xb4, 0x8c, 0xcc, 0x31, 0x54,
+	0xaa, 0x52, 0x54, 0x0e, 0x1c, 0x73, 0xe1, 0x90, 0x43, 0xfe, 0x87, 0x9c, 0x72, 0xca, 0x81, 0xaa,
+	0xe4, 0xc0, 0x21, 0x87, 0x1c, 0x52, 0x24, 0xc5, 0xde, 0xf2, 0x0f, 0xe4, 0x90, 0x43, 0x52, 0xfd,
+	0x31, 0x5f, 0x92, 0xc6, 0x92, 0x21, 0x95, 0xaa, 0x54, 0x6e, 0xdd, 0x6f, 0xde, 0x7b, 0xdd, 0xfd,
+	0xba, 0xfb, 0xbd, 0xf7, 0x7b, 0xd3, 0xf0, 0x04, 0xc1, 0x86, 0x86, 0xed, 0x91, 0x6e, 0x90, 0x2d,
+	0xb5, 0xdb, 0xd3, 0xb7, 0xc8, 0xb9, 0x85, 0x9d, 0x4d, 0xcb, 0x36, 0x89, 0x89, 0x2a, 0xfe, 0xc7,
+	0x4d, 0xfa, 0xb1, 0xfe, 0x64, 0x80, 0xbb, 0x67, 0x9f, 0x5b, 0xc4, 0xdc, 0xb2, 0x6c, 0xd3, 0x3c,
+	0xe5, 0xfc, 0xf5, 0xeb, 0x81, 0xcf, 0x4c, 0x4f, 0x50, 0x5b, 0xe8, 0xab, 0x10, 0x7e, 0x88, 0xcf,
+	0xdd, 0xaf, 0x4f, 0xce, 0xc8, 0x5a, 0xaa, 0xad, 0x8e, 0xdc, 0xcf, 0xeb, 0x7d, 0xd3, 0xec, 0x0f,
+	0xf1, 0x16, 0xeb, 0x75, 0xc7, 0xa7, 0x5b, 0x44, 0x1f, 0x61, 0x87, 0xa8, 0x23, 0x4b, 0x30, 0xac,
+	0xf6, 0xcd, 0xbe, 0xc9, 0x9a, 0x5b, 0xb4, 0xc5, 0xa9, 0xd2, 0xbf, 0x72, 0x90, 0x95, 0xf1, 0x87,
+	0x63, 0xec, 0x10, 0xb4, 0x0d, 0x29, 0xdc, 0x1b, 0x98, 0xb5, 0xf8, 0x46, 0xfc, 0x66, 0x61, 0xfb,
+	0xfa, 0xe6, 0xd4, 0xe2, 0x36, 0x05, 0x5f, 0xab, 0x37, 0x30, 0xdb, 0x31, 0x99, 0xf1, 0xa2, 0x3b,
+	0x90, 0x3e, 0x1d, 0x8e, 0x9d, 0x41, 0x2d, 0xc1, 0x84, 0x9e, 0x8c, 0x12, 0xba, 0x47, 0x99, 0xda,
+	0x31, 0x99, 0x73, 0xd3, 0xa1, 0x74, 0xe3, 0xd4, 0xac, 0x25, 0x2f, 0x1e, 0x6a, 0xd7, 0x38, 0x65,
+	0x43, 0x51, 0x5e, 0xd4, 0x00, 0xd0, 0x0d, 0x9d, 0x28, 0xbd, 0x81, 0xaa, 0x1b, 0xb5, 0x34, 0x93,
+	0x7c, 0x2a, 0x5a, 0x52, 0x27, 0x4d, 0xca, 0xd8, 0x8e, 0xc9, 0x79, 0xdd, 0xed, 0xd0, 0xe9, 0x7e,
+	0x38, 0xc6, 0xf6, 0x79, 0x2d, 0x73, 0xf1, 0x74, 0x7f, 0x48, 0x99, 0xe8, 0x74, 0x19, 0x37, 0x6a,
+	0x41, 0xa1, 0x8b, 0xfb, 0xba, 0xa1, 0x74, 0x87, 0x66, 0xef, 0x61, 0x2d, 0xcb, 0x84, 0xa5, 0x28,
+	0xe1, 0x06, 0x65, 0x6d, 0x50, 0xce, 0x76, 0x4c, 0x86, 0xae, 0xd7, 0x43, 0xdf, 0x85, 0x5c, 0x6f,
+	0x80, 0x7b, 0x0f, 0x15, 0x32, 0xa9, 0xe5, 0x98, 0x8e, 0xf5, 0x28, 0x1d, 0x4d, 0xca, 0xd7, 0x99,
+	0xb4, 0x63, 0x72, 0xb6, 0xc7, 0x9b, 0x74, 0xfd, 0x1a, 0x1e, 0xea, 0x67, 0xd8, 0xa6, 0xf2, 0xf9,
+	0x8b, 0xd7, 0x7f, 0x97, 0x73, 0x32, 0x0d, 0x79, 0xcd, 0xed, 0xa0, 0xef, 0x43, 0x1e, 0x1b, 0x9a,
+	0x58, 0x06, 0x30, 0x15, 0x1b, 0x91, 0xfb, 0x6c, 0x68, 0xee, 0x22, 0x72, 0x58, 0xb4, 0xd1, 0x6b,
+	0x90, 0xe9, 0x99, 0xa3, 0x91, 0x4e, 0x6a, 0x05, 0x26, 0xbd, 0x16, 0xb9, 0x00, 0xc6, 0xd5, 0x8e,
+	0xc9, 0x82, 0x1f, 0x1d, 0x40, 0x79, 0xa8, 0x3b, 0x44, 0x71, 0x0c, 0xd5, 0x72, 0x06, 0x26, 0x71,
+	0x6a, 0x45, 0xa6, 0xe1, 0xe9, 0x28, 0x0d, 0xfb, 0xba, 0x43, 0x8e, 0x5d, 0xe6, 0x76, 0x4c, 0x2e,
+	0x0d, 0x83, 0x04, 0xaa, 0xcf, 0x3c, 0x3d, 0xc5, 0xb6, 0xa7, 0xb0, 0x56, 0xba, 0x58, 0xdf, 0x21,
+	0xe5, 0x76, 0xe5, 0xa9, 0x3e, 0x33, 0x48, 0x40, 0x3f, 0x86, 0x2b, 0x43, 0x53, 0xd5, 0x3c, 0x75,
+	0x4a, 0x6f, 0x30, 0x36, 0x1e, 0xd6, 0xca, 0x4c, 0xe9, 0xad, 0xc8, 0x49, 0x9a, 0xaa, 0xe6, 0xaa,
+	0x68, 0x52, 0x81, 0x76, 0x4c, 0x5e, 0x19, 0x4e, 0x13, 0xd1, 0x03, 0x58, 0x55, 0x2d, 0x6b, 0x78,
+	0x3e, 0xad, 0xbd, 0xc2, 0xb4, 0xdf, 0x8e, 0xd2, 0xbe, 0x43, 0x65, 0xa6, 0xd5, 0x23, 0x75, 0x86,
+	0x8a, 0x3a, 0x50, 0xb5, 0x6c, 0x6c, 0xa9, 0x36, 0x56, 0x2c, 0xdb, 0xb4, 0x4c, 0x47, 0x1d, 0xd6,
+	0xaa, 0x4c, 0xf7, 0xb3, 0x51, 0xba, 0x8f, 0x38, 0xff, 0x91, 0x60, 0x6f, 0xc7, 0xe4, 0x8a, 0x15,
+	0x26, 0x71, 0xad, 0x66, 0x0f, 0x3b, 0x8e, 0xaf, 0x75, 0x65, 0x91, 0x56, 0xc6, 0x1f, 0xd6, 0x1a,
+	0x22, 0x35, 0xb2, 0x90, 0x3e, 0x53, 0x87, 0x63, 0xfc, 0x76, 0x2a, 0x97, 0xaa, 0xa6, 0xa5, 0x67,
+	0xa1, 0x10, 0x70, 0x2c, 0xa8, 0x06, 0xd9, 0x11, 0x76, 0x1c, 0xb5, 0x8f, 0x99, 0x1f, 0xca, 0xcb,
+	0x6e, 0x57, 0x2a, 0x43, 0x31, 0xe8, 0x4c, 0xa4, 0xcf, 0xe2, 0x9e, 0x24, 0xf5, 0x13, 0x54, 0xf2,
+	0x0c, 0xdb, 0x8e, 0x6e, 0x1a, 0xae, 0xa4, 0xe8, 0xa2, 0x1b, 0x50, 0x62, 0x27, 0x5e, 0x71, 0xbf,
+	0x53, 0x67, 0x95, 0x92, 0x8b, 0x8c, 0x78, 0x5f, 0x30, 0xad, 0x43, 0xc1, 0xda, 0xb6, 0x3c, 0x96,
+	0x24, 0x63, 0x01, 0x6b, 0xdb, 0x72, 0x19, 0x9e, 0x82, 0x22, 0x5d, 0xa9, 0xc7, 0x91, 0x62, 0x83,
+	0x14, 0x28, 0x4d, 0xb0, 0x48, 0x7f, 0x4c, 0x40, 0x75, 0xda, 0x01, 0xa1, 0xd7, 0x20, 0x45, 0x7d,
+	0xb1, 0x70, 0xab, 0xf5, 0x4d, 0xee, 0xa8, 0x37, 0x5d, 0x47, 0xbd, 0xd9, 0x71, 0x1d, 0x75, 0x23,
+	0xf7, 0xc5, 0x57, 0xeb, 0xb1, 0xcf, 0xfe, 0xba, 0x1e, 0x97, 0x99, 0x04, 0xba, 0x46, 0xfd, 0x85,
+	0xaa, 0x1b, 0x8a, 0xae, 0xb1, 0x29, 0xe7, 0xa9, 0x33, 0x50, 0x75, 0x63, 0x57, 0x43, 0xfb, 0x50,
+	0xed, 0x99, 0x86, 0x83, 0x0d, 0x67, 0xec, 0x28, 0x3c, 0x10, 0x08, 0x67, 0x1a, 0x72, 0x09, 0x3c,
+	0xbc, 0x34, 0x5d, 0xce, 0x23, 0xc6, 0x28, 0x57, 0x7a, 0x61, 0x02, 0xba, 0x07, 0x70, 0xa6, 0x0e,
+	0x75, 0x4d, 0x25, 0xa6, 0xed, 0xd4, 0x52, 0x1b, 0xc9, 0xb9, 0x7e, 0xe1, 0xbe, 0xcb, 0x72, 0x62,
+	0x69, 0x2a, 0xc1, 0x8d, 0x14, 0x9d, 0xae, 0x1c, 0x90, 0x44, 0xcf, 0x40, 0x45, 0xb5, 0x2c, 0xc5,
+	0x21, 0x2a, 0xc1, 0x4a, 0xf7, 0x9c, 0x60, 0x87, 0xf9, 0xe9, 0xa2, 0x5c, 0x52, 0x2d, 0xeb, 0x98,
+	0x52, 0x1b, 0x94, 0x88, 0x9e, 0x86, 0x32, 0xf5, 0xc9, 0xba, 0x3a, 0x54, 0x06, 0x58, 0xef, 0x0f,
+	0x08, 0xf3, 0xc7, 0x49, 0xb9, 0x24, 0xa8, 0x6d, 0x46, 0x94, 0x34, 0x6f, 0xc7, 0x99, 0x3f, 0x46,
+	0x08, 0x52, 0x9a, 0x4a, 0x54, 0x66, 0xc9, 0xa2, 0xcc, 0xda, 0x94, 0x66, 0xa9, 0x64, 0x20, 0xec,
+	0xc3, 0xda, 0xe8, 0x2a, 0x64, 0x84, 0xda, 0x24, 0x53, 0x2b, 0x7a, 0x68, 0x15, 0xd2, 0x96, 0x6d,
+	0x9e, 0x61, 0xb6, 0x75, 0x39, 0x99, 0x77, 0xa4, 0x4f, 0x12, 0xb0, 0x32, 0xe3, 0xb9, 0xa9, 0xde,
+	0x81, 0xea, 0x0c, 0xdc, 0xb1, 0x68, 0x1b, 0xbd, 0x42, 0xf5, 0xaa, 0x1a, 0xb6, 0x45, 0xb4, 0xab,
+	0xcd, 0x9a, 0xba, 0xcd, 0xbe, 0x0b, 0xd3, 0x08, 0x6e, 0xb4, 0x07, 0xd5, 0xa1, 0xea, 0x10, 0x85,
+	0x7b, 0x42, 0x25, 0x10, 0xf9, 0x9e, 0x98, 0x31, 0x32, 0xf7, 0x9b, 0xf4, 0x40, 0x0b, 0x25, 0x65,
+	0x2a, 0xea, 0x53, 0xd1, 0x09, 0xac, 0x76, 0xcf, 0x3f, 0x56, 0x0d, 0xa2, 0x1b, 0x58, 0x99, 0xd9,
+	0xb5, 0xd9, 0x50, 0xfa, 0x8e, 0xee, 0x74, 0xf1, 0x40, 0x3d, 0xd3, 0x4d, 0x77, 0x5a, 0x57, 0x3c,
+	0x79, 0x6f, 0x47, 0x1d, 0x49, 0x86, 0x72, 0x38, 0xf4, 0xa0, 0x32, 0x24, 0xc8, 0x44, 0xac, 0x3f,
+	0x41, 0x26, 0xe8, 0x45, 0x48, 0xd1, 0x35, 0xb2, 0xb5, 0x97, 0xe7, 0x0c, 0x24, 0xe4, 0x3a, 0xe7,
+	0x16, 0x96, 0x19, 0xa7, 0x24, 0x79, 0xb7, 0xc1, 0x0b, 0x47, 0xd3, 0x5a, 0xa5, 0x5b, 0x50, 0x99,
+	0x8a, 0x37, 0x81, 0xed, 0x8b, 0x07, 0xb7, 0x4f, 0xaa, 0x40, 0x29, 0x14, 0x5c, 0xa4, 0xab, 0xb0,
+	0x3a, 0x2f, 0x56, 0x48, 0x03, 0x8f, 0x1e, 0xf2, 0xf9, 0xe8, 0x0e, 0xe4, 0xbc, 0x60, 0xc1, 0x6f,
+	0xe3, 0xb5, 0x99, 0x55, 0xb8, 0xcc, 0xb2, 0xc7, 0x4a, 0xaf, 0x21, 0x3d, 0xd5, 0xec, 0x38, 0x24,
+	0xd8, 0xc4, 0xb3, 0xaa, 0x65, 0xb5, 0x55, 0x67, 0x20, 0xbd, 0x0f, 0xb5, 0xa8, 0x40, 0x30, 0xb5,
+	0x8c, 0x94, 0x77, 0x0a, 0xaf, 0x42, 0xe6, 0xd4, 0xb4, 0x47, 0x2a, 0x61, 0xca, 0x4a, 0xb2, 0xe8,
+	0xd1, 0xd3, 0xc9, 0x83, 0x42, 0x92, 0x91, 0x79, 0x47, 0x52, 0xe0, 0x5a, 0x64, 0x30, 0xa0, 0x22,
+	0xba, 0xa1, 0x61, 0x6e, 0xcf, 0x92, 0xcc, 0x3b, 0xbe, 0x22, 0x3e, 0x59, 0xde, 0xa1, 0xc3, 0x3a,
+	0x6c, 0xad, 0x4c, 0x7f, 0x5e, 0x16, 0x3d, 0xe9, 0x0f, 0x49, 0xb8, 0x3a, 0x3f, 0x24, 0xa0, 0x0d,
+	0x28, 0x8e, 0xd4, 0x89, 0x42, 0x26, 0xe2, 0x2e, 0xf3, 0xed, 0x80, 0x91, 0x3a, 0xe9, 0x4c, 0xf8,
+	0x45, 0xae, 0x42, 0x92, 0x4c, 0x9c, 0x5a, 0x62, 0x23, 0x79, 0xb3, 0x28, 0xd3, 0x26, 0x3a, 0x81,
+	0x95, 0xa1, 0xd9, 0x53, 0x87, 0x4a, 0xe0, 0xc4, 0x8b, 0xc3, 0x7e, 0x63, 0xc6, 0xd8, 0xad, 0x09,
+	0xa3, 0x68, 0x33, 0x87, 0xbe, 0xc2, 0x74, 0xec, 0x7b, 0x27, 0x1f, 0xdd, 0x85, 0xc2, 0xc8, 0x3f,
+	0xc8, 0x97, 0x38, 0xec, 0x41, 0xb1, 0xc0, 0x96, 0xa4, 0x43, 0x8e, 0xc1, 0x75, 0xd1, 0x99, 0x4b,
+	0xbb, 0xe8, 0x17, 0x61, 0xd5, 0xc0, 0x13, 0x12, 0xb8, 0x88, 0xfc, 0x9c, 0x64, 0x99, 0xe9, 0x11,
+	0xfd, 0xe6, 0x5f, 0x32, 0x7a, 0x64, 0xd0, 0x2d, 0x16, 0x54, 0x2d, 0xd3, 0xc1, 0xb6, 0xa2, 0x6a,
+	0x9a, 0x8d, 0x1d, 0x87, 0x25, 0x83, 0x45, 0x16, 0x29, 0x19, 0x7d, 0x87, 0x93, 0xd1, 0x4b, 0xf0,
+	0x98, 0xee, 0x28, 0x86, 0x69, 0x88, 0xf0, 0xab, 0x1b, 0x7d, 0xc5, 0x30, 0x35, 0xcc, 0x92, 0xbf,
+	0x9c, 0x8c, 0x74, 0xe7, 0xc0, 0x34, 0x8e, 0xdc, 0x4f, 0x07, 0xa6, 0x86, 0xa5, 0x5f, 0x04, 0x77,
+	0x33, 0x14, 0x77, 0xdd, 0xbd, 0x8a, 0xfb, 0x7b, 0x75, 0x0c, 0xab, 0x62, 0x48, 0x2d, 0xb4, 0x5d,
+	0x89, 0x65, 0x7d, 0x13, 0x72, 0xc5, 0xa3, 0x77, 0x2a, 0xf9, 0xcd, 0x76, 0xca, 0x75, 0xbf, 0xa9,
+	0x80, 0xfb, 0xfd, 0xdf, 0xda, 0x3d, 0xe9, 0x4f, 0x79, 0xc8, 0xc9, 0xd8, 0xb1, 0x68, 0xac, 0x45,
+	0x0d, 0xc8, 0xe3, 0x49, 0x0f, 0x5b, 0xc4, 0x4d, 0x4f, 0xe6, 0xe3, 0x07, 0xce, 0xdd, 0x72, 0x39,
+	0x69, 0xf2, 0xee, 0x89, 0xa1, 0x97, 0x05, 0x3e, 0x8b, 0x86, 0x5a, 0x42, 0x3c, 0x08, 0xd0, 0x5e,
+	0x71, 0x01, 0x5a, 0x32, 0x32, 0x5f, 0xe7, 0x52, 0x53, 0x08, 0xed, 0x65, 0x81, 0xd0, 0x52, 0x0b,
+	0x06, 0x0b, 0x41, 0xb4, 0x66, 0x08, 0xa2, 0x65, 0x16, 0x2c, 0x33, 0x02, 0xa3, 0xbd, 0xe2, 0x62,
+	0xb4, 0xec, 0x82, 0x19, 0x4f, 0x81, 0xb4, 0x7b, 0x61, 0x90, 0x96, 0x8b, 0xf0, 0x39, 0xae, 0x74,
+	0x24, 0x4a, 0x7b, 0x33, 0x80, 0xd2, 0xf2, 0x91, 0x10, 0x89, 0x2b, 0x99, 0x03, 0xd3, 0x9a, 0x21,
+	0x98, 0x06, 0x0b, 0x6c, 0x10, 0x81, 0xd3, 0xde, 0x0a, 0xe2, 0xb4, 0x42, 0x24, 0xd4, 0x13, 0xfb,
+	0x3d, 0x0f, 0xa8, 0xbd, 0xee, 0x01, 0xb5, 0x62, 0x24, 0xd2, 0x14, 0x6b, 0x98, 0x46, 0x6a, 0x87,
+	0x33, 0x48, 0x8d, 0x23, 0xab, 0x67, 0x22, 0x55, 0x2c, 0x80, 0x6a, 0x87, 0x33, 0x50, 0xad, 0xbc,
+	0x40, 0xe1, 0x02, 0xac, 0xf6, 0x93, 0xf9, 0x58, 0x2d, 0x1a, 0x4d, 0x89, 0x69, 0x2e, 0x07, 0xd6,
+	0x94, 0x08, 0xb0, 0xc6, 0x01, 0xd5, 0x73, 0x91, 0xea, 0x97, 0x46, 0x6b, 0x27, 0x73, 0xd0, 0x1a,
+	0xc7, 0x55, 0x37, 0x23, 0x95, 0x2f, 0x01, 0xd7, 0x4e, 0xe6, 0xc0, 0x35, 0xb4, 0x50, 0xed, 0x65,
+	0xf0, 0x5a, 0xba, 0x9a, 0x91, 0x6e, 0xd1, 0x6c, 0x79, 0xca, 0x4f, 0xd1, 0x94, 0x03, 0xdb, 0xb6,
+	0x69, 0x0b, 0xe4, 0xc5, 0x3b, 0xd2, 0x4d, 0x9a, 0xbf, 0xfb, 0x3e, 0xe9, 0x02, 0x6c, 0xc7, 0x52,
+	0xbb, 0x80, 0x1f, 0x92, 0x7e, 0x1b, 0xf7, 0x65, 0x59, 0xda, 0x1b, 0xcc, 0xfd, 0xf3, 0x22, 0xf7,
+	0x0f, 0x20, 0xbe, 0x44, 0x18, 0xf1, 0xad, 0x43, 0x81, 0xa6, 0x6c, 0x53, 0x60, 0x4e, 0xb5, 0x3c,
+	0x30, 0x77, 0x1b, 0x56, 0x58, 0xc4, 0xe3, 0xb8, 0x50, 0x84, 0x95, 0x14, 0x0b, 0x2b, 0x15, 0xfa,
+	0x81, 0x5f, 0x28, 0x1e, 0x5f, 0x5e, 0x80, 0x2b, 0x01, 0x5e, 0x2f, 0x15, 0xe4, 0xc8, 0xa6, 0xea,
+	0x71, 0xef, 0x88, 0x9c, 0xf0, 0xf7, 0x71, 0xdf, 0x42, 0x3e, 0x0a, 0x9c, 0x07, 0xd8, 0xe2, 0xff,
+	0x21, 0xc0, 0x96, 0xf8, 0xc6, 0x80, 0x2d, 0x98, 0xda, 0x26, 0xc3, 0xa9, 0xed, 0x3f, 0xe2, 0xfe,
+	0x9e, 0x78, 0xf0, 0xab, 0x47, 0xb3, 0x0f, 0x9e, 0x6c, 0xb2, 0x36, 0x4d, 0x2a, 0x86, 0x66, 0x5f,
+	0xa4, 0x94, 0xb4, 0x49, 0xb9, 0xbc, 0xc0, 0x91, 0x17, 0x71, 0xc1, 0xcb, 0x53, 0x79, 0xe0, 0x16,
+	0x79, 0x6a, 0x15, 0x92, 0x0f, 0x31, 0x2f, 0xc5, 0x15, 0x65, 0xda, 0xa4, 0x7c, 0xec, 0xa8, 0x89,
+	0x00, 0xcc, 0x3b, 0xe8, 0x35, 0xc8, 0xb3, 0x22, 0xaa, 0x62, 0x5a, 0x8e, 0x70, 0xeb, 0xa1, 0xdc,
+	0x84, 0xd7, 0x4a, 0x37, 0x8f, 0x28, 0xcf, 0xa1, 0xe5, 0xc8, 0x39, 0x4b, 0xb4, 0x02, 0x19, 0x43,
+	0x3e, 0x94, 0x31, 0x5c, 0x87, 0x3c, 0x9d, 0xbd, 0x63, 0xa9, 0x3d, 0xcc, 0x5c, 0x74, 0x5e, 0xf6,
+	0x09, 0xd2, 0x03, 0x40, 0xb3, 0x41, 0x02, 0xb5, 0x21, 0x83, 0xcf, 0xb0, 0x41, 0x78, 0x06, 0x55,
+	0xd8, 0xbe, 0x3a, 0x9b, 0xcd, 0xd2, 0xcf, 0x8d, 0x1a, 0x35, 0xf2, 0xdf, 0xbf, 0x5a, 0xaf, 0x72,
+	0xee, 0xe7, 0xcd, 0x91, 0x4e, 0xf0, 0xc8, 0x22, 0xe7, 0xb2, 0x90, 0x97, 0xfe, 0x92, 0xa0, 0x98,
+	0x27, 0x14, 0x40, 0xe6, 0xda, 0xd6, 0x3d, 0xf2, 0x89, 0x00, 0xdc, 0x5d, 0xce, 0xde, 0x6b, 0x00,
+	0x7d, 0xd5, 0x51, 0x3e, 0x52, 0x0d, 0x82, 0x35, 0x61, 0xf4, 0x00, 0x05, 0xd5, 0x21, 0x47, 0x7b,
+	0x63, 0x07, 0x6b, 0x02, 0x79, 0x7b, 0xfd, 0xc0, 0x3a, 0xb3, 0xdf, 0x6e, 0x9d, 0x61, 0x2b, 0xe7,
+	0xa6, 0xac, 0x1c, 0xc0, 0x23, 0xf9, 0x20, 0x1e, 0xa1, 0x73, 0xb3, 0x6c, 0xdd, 0xb4, 0x75, 0x72,
+	0xce, 0xb6, 0x26, 0x29, 0x7b, 0x7d, 0x74, 0x03, 0x4a, 0x23, 0x3c, 0xb2, 0x4c, 0x73, 0xa8, 0x70,
+	0x77, 0x53, 0x60, 0xa2, 0x45, 0x41, 0x6c, 0x31, 0xaf, 0xf3, 0xf3, 0x84, 0x7f, 0xff, 0x7c, 0xdc,
+	0xf9, 0x7f, 0x67, 0x60, 0xe9, 0x97, 0xac, 0x18, 0x15, 0x4e, 0x11, 0xd0, 0x31, 0xac, 0x78, 0xd7,
+	0x5f, 0x19, 0x33, 0xb7, 0xe0, 0x1e, 0xe8, 0x65, 0xfd, 0x47, 0xf5, 0x2c, 0x4c, 0x76, 0xd0, 0x7b,
+	0xf0, 0xf8, 0x94, 0x6f, 0xf3, 0x54, 0x27, 0x96, 0x75, 0x71, 0x8f, 0x85, 0x5d, 0x9c, 0xab, 0xda,
+	0x37, 0x56, 0xf2, 0x5b, 0xde, 0xba, 0x5d, 0x28, 0x87, 0x33, 0x9e, 0xb9, 0xdb, 0x7f, 0x03, 0x4a,
+	0x36, 0x26, 0xaa, 0x6e, 0x28, 0xa1, 0x0a, 0x52, 0x91, 0x13, 0x45, 0x5d, 0xea, 0x08, 0x1e, 0x9b,
+	0x9b, 0xf9, 0xa0, 0x57, 0x21, 0xef, 0x27, 0x4d, 0xdc, 0xaa, 0x17, 0x54, 0x18, 0x7c, 0x5e, 0xe9,
+	0x77, 0x71, 0x5f, 0x65, 0xb8, 0x66, 0xd1, 0x82, 0x8c, 0x8d, 0x9d, 0xf1, 0x90, 0x57, 0x11, 0xca,
+	0xdb, 0x2f, 0x2c, 0x97, 0x33, 0x51, 0xea, 0x78, 0x48, 0x64, 0x21, 0x2c, 0x3d, 0x80, 0x0c, 0xa7,
+	0xa0, 0x02, 0x64, 0x4f, 0x0e, 0xf6, 0x0e, 0x0e, 0xdf, 0x3d, 0xa8, 0xc6, 0x10, 0x40, 0x66, 0xa7,
+	0xd9, 0x6c, 0x1d, 0x75, 0xaa, 0x71, 0x94, 0x87, 0xf4, 0x4e, 0xe3, 0x50, 0xee, 0x54, 0x13, 0x94,
+	0x2c, 0xb7, 0xde, 0x6e, 0x35, 0x3b, 0xd5, 0x24, 0x5a, 0x81, 0x12, 0x6f, 0x2b, 0xf7, 0x0e, 0xe5,
+	0x77, 0x76, 0x3a, 0xd5, 0x54, 0x80, 0x74, 0xdc, 0x3a, 0xb8, 0xdb, 0x92, 0xab, 0x69, 0xe9, 0x25,
+	0xb8, 0x16, 0x99, 0x65, 0xf9, 0x05, 0x89, 0x78, 0xa0, 0x20, 0x21, 0xfd, 0x2a, 0x01, 0xf5, 0xe8,
+	0xd4, 0x09, 0xbd, 0x3d, 0xb5, 0xf0, 0xed, 0x4b, 0xe4, 0x5d, 0x53, 0xab, 0x47, 0x4f, 0x43, 0xd9,
+	0xc6, 0xa7, 0x98, 0xf4, 0x06, 0x3c, 0x95, 0xe3, 0x21, 0xb3, 0x24, 0x97, 0x04, 0x95, 0x09, 0x39,
+	0x9c, 0xed, 0x03, 0xdc, 0x23, 0x0a, 0xf7, 0x45, 0xfc, 0xd0, 0xe5, 0x29, 0x1b, 0xa5, 0x1e, 0x73,
+	0xa2, 0xf4, 0xfe, 0xa5, 0x6c, 0x99, 0x87, 0xb4, 0xdc, 0xea, 0xc8, 0xef, 0x55, 0x93, 0x08, 0x41,
+	0x99, 0x35, 0x95, 0xe3, 0x83, 0x9d, 0xa3, 0xe3, 0xf6, 0x21, 0xb5, 0xe5, 0x15, 0xa8, 0xb8, 0xb6,
+	0x74, 0x89, 0x69, 0xe9, 0x39, 0x78, 0x3c, 0x22, 0xef, 0x9b, 0x45, 0xf1, 0xd2, 0xaf, 0xe3, 0x41,
+	0xee, 0x30, 0xe6, 0x3f, 0x84, 0x8c, 0x43, 0x54, 0x32, 0x76, 0x84, 0x11, 0x5f, 0x5d, 0x36, 0x11,
+	0xdc, 0x74, 0x1b, 0xc7, 0x4c, 0x5c, 0x16, 0x6a, 0xa4, 0x3b, 0x50, 0x0e, 0x7f, 0x89, 0xb6, 0x81,
+	0x7f, 0x88, 0x12, 0xd2, 0x7b, 0x00, 0x81, 0x12, 0xe6, 0x2a, 0xa4, 0x6d, 0x73, 0x6c, 0x68, 0x6c,
+	0x52, 0x69, 0x99, 0x77, 0xd0, 0x1d, 0x48, 0x9f, 0x99, 0xdc, 0x67, 0xcc, 0xbf, 0x38, 0xf7, 0x4d,
+	0x82, 0x03, 0xc5, 0x07, 0xce, 0x2d, 0xe9, 0x80, 0x66, 0xcb, 0x48, 0x11, 0x43, 0xbc, 0x19, 0x1e,
+	0xe2, 0xa9, 0xc8, 0x82, 0xd4, 0xfc, 0xa1, 0x3e, 0x86, 0x34, 0xf3, 0x36, 0xd4, 0x73, 0xb0, 0x52,
+	0xa8, 0x48, 0x46, 0x69, 0x1b, 0xfd, 0x14, 0x40, 0x25, 0xc4, 0xd6, 0xbb, 0x63, 0x7f, 0x80, 0xf5,
+	0xf9, 0xde, 0x6a, 0xc7, 0xe5, 0x6b, 0x5c, 0x17, 0x6e, 0x6b, 0xd5, 0x17, 0x0d, 0xb8, 0xae, 0x80,
+	0x42, 0xe9, 0x00, 0xca, 0x61, 0x59, 0x37, 0x7d, 0xe2, 0x73, 0x08, 0xa7, 0x4f, 0x3c, 0x1b, 0x16,
+	0xe9, 0x93, 0x97, 0x7c, 0x25, 0x79, 0xd5, 0x9b, 0x75, 0xa4, 0x4f, 0xe3, 0x90, 0xeb, 0x4c, 0xc4,
+	0x39, 0x8e, 0xa8, 0xb8, 0xfa, 0xa2, 0x89, 0x60, 0x7d, 0x91, 0x97, 0x70, 0x93, 0x5e, 0x61, 0xf8,
+	0x2d, 0xef, 0xa6, 0xa6, 0x96, 0x45, 0xbb, 0x6e, 0x81, 0x5c, 0x78, 0xa7, 0x37, 0x20, 0xef, 0xc5,
+	0x1a, 0x9a, 0xd5, 0xbb, 0x95, 0x95, 0xb8, 0x48, 0x49, 0x45, 0x3d, 0x6c, 0x15, 0xd2, 0x96, 0xf9,
+	0x91, 0xa8, 0x60, 0x26, 0x65, 0xde, 0x91, 0x34, 0xa8, 0x4c, 0x05, 0x2a, 0xf4, 0x06, 0x64, 0xad,
+	0x71, 0x57, 0x71, 0xcd, 0x33, 0x55, 0x7f, 0x72, 0xf3, 0xc5, 0x71, 0x77, 0xa8, 0xf7, 0xf6, 0xf0,
+	0xb9, 0x3b, 0x19, 0x6b, 0xdc, 0xdd, 0xe3, 0x56, 0xe4, 0xa3, 0x24, 0x82, 0xa3, 0x9c, 0x41, 0xce,
+	0x3d, 0x14, 0xe8, 0x7b, 0x90, 0xf7, 0x62, 0xa0, 0xf7, 0x5b, 0x27, 0x32, 0x78, 0x0a, 0xf5, 0xbe,
+	0x08, 0x05, 0x1f, 0x8e, 0xde, 0x37, 0xdc, 0xaa, 0x1b, 0x47, 0xf9, 0x09, 0xb6, 0x3b, 0x15, 0xfe,
+	0x61, 0xdf, 0x05, 0x15, 0xd2, 0x6f, 0xe2, 0x50, 0x9d, 0x3e, 0x95, 0xff, 0xcd, 0x09, 0x50, 0xa7,
+	0x48, 0x4f, 0xbf, 0x82, 0xe9, 0x24, 0x3c, 0x34, 0x55, 0x94, 0x4b, 0x94, 0xda, 0x72, 0x89, 0xd2,
+	0x27, 0x09, 0x28, 0x04, 0x6a, 0x7a, 0xe8, 0x3b, 0x81, 0x2b, 0x52, 0x9e, 0x93, 0x5b, 0x04, 0x78,
+	0xfd, 0x3f, 0x06, 0xe1, 0x85, 0x25, 0x2e, 0xbf, 0xb0, 0xa8, 0x3f, 0x3f, 0x6e, 0x89, 0x30, 0x75,
+	0xe9, 0x12, 0xe1, 0xf3, 0x80, 0x88, 0x49, 0xd4, 0xa1, 0x72, 0x66, 0x12, 0xdd, 0xe8, 0x2b, 0xfc,
+	0x68, 0xf0, 0x8c, 0xaf, 0xca, 0xbe, 0xdc, 0x67, 0x1f, 0x8e, 0xd8, 0x29, 0xf9, 0x59, 0x1c, 0x72,
+	0x5e, 0xe8, 0xbe, 0xec, 0x0f, 0x80, 0xab, 0x90, 0x11, 0xd1, 0x89, 0xff, 0x01, 0x10, 0xbd, 0xb9,
+	0xb5, 0xd0, 0x3a, 0xe4, 0x46, 0x98, 0xa8, 0x2c, 0x7f, 0xe1, 0x40, 0xd4, 0xeb, 0xdf, 0x7e, 0x1d,
+	0x0a, 0x81, 0x7f, 0x31, 0xd4, 0x4f, 0x1c, 0xb4, 0xde, 0xad, 0xc6, 0xea, 0xd9, 0x4f, 0x3f, 0xdf,
+	0x48, 0x1e, 0xe0, 0x8f, 0xe8, 0x0d, 0x93, 0x5b, 0xcd, 0x76, 0xab, 0xb9, 0x57, 0x8d, 0xd7, 0x0b,
+	0x9f, 0x7e, 0xbe, 0x91, 0x95, 0x31, 0x2b, 0x5f, 0xdd, 0xde, 0x83, 0xca, 0xd4, 0xc6, 0x84, 0xfd,
+	0x3b, 0x82, 0xf2, 0xdd, 0x93, 0xa3, 0xfd, 0xdd, 0xe6, 0x4e, 0xa7, 0xa5, 0xdc, 0x3f, 0xec, 0xb4,
+	0xaa, 0x71, 0xf4, 0x38, 0x5c, 0xd9, 0xdf, 0xfd, 0x41, 0xbb, 0xa3, 0x34, 0xf7, 0x77, 0x5b, 0x07,
+	0x1d, 0x65, 0xa7, 0xd3, 0xd9, 0x69, 0xee, 0x55, 0x13, 0xdb, 0xff, 0x04, 0xa8, 0xec, 0x34, 0x9a,
+	0xbb, 0x34, 0x3e, 0xeb, 0x3d, 0x95, 0x15, 0x0a, 0x9a, 0x90, 0x62, 0xa5, 0x80, 0x0b, 0x5f, 0x97,
+	0xd4, 0x2f, 0xae, 0x6d, 0xa2, 0x7b, 0x90, 0x66, 0x55, 0x02, 0x74, 0xf1, 0x73, 0x93, 0xfa, 0x82,
+	0x62, 0x27, 0x9d, 0x0c, 0xbb, 0x4e, 0x17, 0xbe, 0x3f, 0xa9, 0x5f, 0x5c, 0xfb, 0x44, 0x32, 0xe4,
+	0x7d, 0x94, 0xb1, 0xf8, 0x3d, 0x46, 0x7d, 0x09, 0xef, 0x88, 0xf6, 0x21, 0xeb, 0x02, 0xc3, 0x45,
+	0x2f, 0x44, 0xea, 0x0b, 0x8b, 0x93, 0xd4, 0x5c, 0x1c, 0xc0, 0x5f, 0xfc, 0xdc, 0xa5, 0xbe, 0xa0,
+	0xd2, 0x8a, 0x76, 0x21, 0x23, 0x32, 0xe7, 0x05, 0xaf, 0x3e, 0xea, 0x8b, 0x8a, 0x8d, 0xd4, 0x68,
+	0x7e, 0x69, 0x64, 0xf1, 0x23, 0x9e, 0xfa, 0x12, 0x45, 0x64, 0x74, 0x02, 0x10, 0x80, 0xeb, 0x4b,
+	0xbc, 0xce, 0xa9, 0x2f, 0x53, 0x1c, 0x46, 0x87, 0x90, 0xf3, 0xd0, 0xd3, 0xc2, 0xb7, 0x32, 0xf5,
+	0xc5, 0x55, 0x5a, 0xf4, 0x00, 0x4a, 0x61, 0xd4, 0xb0, 0xdc, 0x0b, 0x98, 0xfa, 0x92, 0xe5, 0x57,
+	0xaa, 0x3f, 0x0c, 0x21, 0x96, 0x7b, 0x11, 0x53, 0x5f, 0xb2, 0x1a, 0x8b, 0x3e, 0x80, 0x95, 0xd9,
+	0x14, 0x7f, 0xf9, 0x07, 0x32, 0xf5, 0x4b, 0xd4, 0x67, 0xd1, 0x08, 0xd0, 0x1c, 0x68, 0x70, 0x89,
+	0xf7, 0x32, 0xf5, 0xcb, 0x94, 0x6b, 0x91, 0x06, 0x95, 0xe9, 0x7c, 0x7b, 0xd9, 0xf7, 0x33, 0xf5,
+	0xa5, 0x4b, 0xb7, 0x7c, 0x94, 0x70, 0x9e, 0xbe, 0xec, 0x7b, 0x9a, 0xfa, 0xd2, 0x95, 0xdc, 0xc6,
+	0xce, 0x17, 0x5f, 0xaf, 0xc5, 0xbf, 0xfc, 0x7a, 0x2d, 0xfe, 0xb7, 0xaf, 0xd7, 0xe2, 0x9f, 0x3d,
+	0x5a, 0x8b, 0x7d, 0xf9, 0x68, 0x2d, 0xf6, 0xe7, 0x47, 0x6b, 0xb1, 0x1f, 0x3d, 0xdb, 0xd7, 0xc9,
+	0x60, 0xdc, 0xdd, 0xec, 0x99, 0xa3, 0xad, 0x9e, 0x39, 0xc2, 0xa4, 0x7b, 0x4a, 0xfc, 0x86, 0xff,
+	0xc8, 0xb1, 0x9b, 0x61, 0xf1, 0xf1, 0xe5, 0x7f, 0x07, 0x00, 0x00, 0xff, 0xff, 0x72, 0xd7, 0xab,
+	0x1b, 0x04, 0x29, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -3684,10 +3693,10 @@ type ABCIApplicationClient interface {
 }
 
 type aBCIApplicationClient struct {
-	cc grpc1.ClientConn
+	cc *grpc.ClientConn
 }
 
-func NewABCIApplicationClient(cc grpc1.ClientConn) ABCIApplicationClient {
+func NewABCIApplicationClient(cc *grpc.ClientConn) ABCIApplicationClient {
 	return &aBCIApplicationClient{cc}
 }
 
@@ -3908,7 +3917,7 @@ func (*UnimplementedABCIApplicationServer) ProcessProposal(ctx context.Context,
 	return nil, status.Errorf(codes.Unimplemented, "method ProcessProposal not implemented")
 }
 
-func RegisterABCIApplicationServer(s grpc1.Server, srv ABCIApplicationServer) {
+func RegisterABCIApplicationServer(s *grpc.Server, srv ABCIApplicationServer) {
 	s.RegisterService(&_ABCIApplication_serviceDesc, srv)
 }
 
@@ -4810,7 +4819,7 @@ func (m *RequestInitChain) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x12
 	}
-	n18, err18 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Time):])
+	n18, err18 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Time):])
 	if err18 != nil {
 		return 0, err18
 	}
@@ -5218,6 +5227,16 @@ func (m *RequestPrepareProposal) MarshalToSizedBuffer(dAtA []byte) (int, error)
 	_ = i
 	var l int
 	_ = l
+	if m.IsNonProposingNode {
+		i--
+		if m.IsNonProposingNode {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i--
+		dAtA[i] = 0x48
+	}
 	if len(m.ProposerAddress) > 0 {
 		i -= len(m.ProposerAddress)
 		copy(dAtA[i:], m.ProposerAddress)
@@ -5232,7 +5251,7 @@ func (m *RequestPrepareProposal) MarshalToSizedBuffer(dAtA []byte) (int, error)
 		i--
 		dAtA[i] = 0x3a
 	}
-	n22, err22 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Time):])
+	n22, err22 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Time):])
 	if err22 != nil {
 		return 0, err22
 	}
@@ -5320,7 +5339,7 @@ func (m *RequestProcessProposal) MarshalToSizedBuffer(dAtA []byte) (int, error)
 		i--
 		dAtA[i] = 0x3a
 	}
-	n24, err24 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Time):])
+	n24, err24 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Time):])
 	if err24 != nil {
 		return 0, err24
 	}
@@ -6989,7 +7008,7 @@ func (m *Misbehavior) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x28
 	}
-	n52, err52 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Time):])
+	n52, err52 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Time):])
 	if err52 != nil {
 		return 0, err52
 	}
@@ -7338,7 +7357,7 @@ func (m *RequestInitChain) Size() (n int) {
 	}
 	var l int
 	_ = l
-	l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Time)
+	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Time)
 	n += 1 + l + sovTypes(uint64(l))
 	l = len(m.ChainId)
 	if l > 0 {
@@ -7550,7 +7569,7 @@ func (m *RequestPrepareProposal) Size() (n int) {
 	if m.Height != 0 {
 		n += 1 + sovTypes(uint64(m.Height))
 	}
-	l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Time)
+	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Time)
 	n += 1 + l + sovTypes(uint64(l))
 	l = len(m.NextValidatorsHash)
 	if l > 0 {
@@ -7560,6 +7579,9 @@ func (m *RequestPrepareProposal) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovTypes(uint64(l))
 	}
+	if m.IsNonProposingNode {
+		n += 2
+	}
 	return n
 }
 
@@ -7590,7 +7612,7 @@ func (m *RequestProcessProposal) Size() (n int) {
 	if m.Height != 0 {
 		n += 1 + sovTypes(uint64(m.Height))
 	}
-	l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Time)
+	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Time)
 	n += 1 + l + sovTypes(uint64(l))
 	l = len(m.NextValidatorsHash)
 	if l > 0 {
@@ -8357,7 +8379,7 @@ func (m *Misbehavior) Size() (n int) {
 	if m.Height != 0 {
 		n += 1 + sovTypes(uint64(m.Height))
 	}
-	l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Time)
+	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Time)
 	n += 1 + l + sovTypes(uint64(l))
 	if m.TotalVotingPower != 0 {
 		n += 1 + sovTypes(uint64(m.TotalVotingPower))
@@ -9349,7 +9371,7 @@ func (m *RequestInitChain) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.Time, dAtA[iNdEx:postIndex]); err != nil {
+			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Time, dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -10781,7 +10803,7 @@ func (m *RequestPrepareProposal) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.Time, dAtA[iNdEx:postIndex]); err != nil {
+			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Time, dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -10853,6 +10875,26 @@ func (m *RequestPrepareProposal) Unmarshal(dAtA []byte) error {
 				m.ProposerAddress = []byte{}
 			}
 			iNdEx = postIndex
+		case 9:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field IsNonProposingNode", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.IsNonProposingNode = bool(v != 0)
 		default:
 			iNdEx = preIndex
 			skippy, err := skipTypes(dAtA[iNdEx:])
@@ -11084,7 +11126,7 @@ func (m *RequestProcessProposal) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.Time, dAtA[iNdEx:postIndex]); err != nil {
+			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Time, dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -15399,7 +15441,7 @@ func (m *Misbehavior) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.Time, dAtA[iNdEx:postIndex]); err != nil {
+			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Time, dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
diff --git a/consensus/byzantine_test.go b/consensus/byzantine_test.go
index 861f5e427..6f5e646dd 100644
--- a/consensus/byzantine_test.go
+++ b/consensus/byzantine_test.go
@@ -189,7 +189,7 @@ func TestByzantinePrevoteEquivocation(t *testing.T) {
 	// proposed will have a valid timestamp
 	lazyProposer := css[1]
 
-	lazyProposer.decideProposal = func(height int64, round int32) {
+	lazyProposer.decideProposal = func(height int64, round int32, isNonProposingNode bool) {
 		lazyProposer.Logger.Info("Lazy Proposer proposing condensed commit")
 		if lazyProposer.privValidator == nil {
 			panic("entered createProposalBlock with privValidator being nil")
@@ -221,7 +221,7 @@ func TestByzantinePrevoteEquivocation(t *testing.T) {
 		proposerAddr := lazyProposer.privValidatorPubKey.Address()
 
 		block, err := lazyProposer.blockExec.CreateProposalBlock(
-			lazyProposer.Height, lazyProposer.state, commit, proposerAddr)
+			lazyProposer.Height, lazyProposer.state, commit, proposerAddr, false)
 		require.NoError(t, err)
 		blockParts, err := block.MakePartSet(types.BlockPartSizeBytes)
 		require.NoError(t, err)
@@ -346,8 +346,8 @@ func TestByzantineConflictingProposalsWithPartition(t *testing.T) {
 			// NOTE: Now, test validators are MockPV, which by default doesn't
 			// do any safety checks.
 			css[i].privValidator.(types.MockPV).DisableChecks()
-			css[i].decideProposal = func(j int32) func(int64, int32) {
-				return func(height int64, round int32) {
+			css[i].decideProposal = func(j int32) func(int64, int32, bool) {
+				return func(height int64, round int32, isNonProposingNode bool) {
 					byzantineDecideProposalFunc(t, height, round, css[j], switches[j])
 				}
 			}(int32(i))
@@ -472,7 +472,7 @@ func byzantineDecideProposalFunc(t *testing.T, height int64, round int32, cs *St
 	// Avoid sending on internalMsgQueue and running consensus state.
 
 	// Create a new proposal block from state/txs from the mempool.
-	block1, err := cs.createProposalBlock()
+	block1, err := cs.createProposalBlock(false)
 	require.NoError(t, err)
 	blockParts1, err := block1.MakePartSet(types.BlockPartSizeBytes)
 	require.NoError(t, err)
@@ -489,7 +489,7 @@ func byzantineDecideProposalFunc(t *testing.T, height int64, round int32, cs *St
 	deliverTxsRange(cs, 0, 1)
 
 	// Create a new proposal block from state/txs from the mempool.
-	block2, err := cs.createProposalBlock()
+	block2, err := cs.createProposalBlock(false)
 	require.NoError(t, err)
 	blockParts2, err := block2.MakePartSet(types.BlockPartSizeBytes)
 	require.NoError(t, err)
diff --git a/consensus/common_test.go b/consensus/common_test.go
index 49a9935c5..63b71d296 100644
--- a/consensus/common_test.go
+++ b/consensus/common_test.go
@@ -207,7 +207,7 @@ func decideProposal(
 	round int32,
 ) (proposal *types.Proposal, block *types.Block) {
 	cs1.mtx.Lock()
-	block, err := cs1.createProposalBlock()
+	block, err := cs1.createProposalBlock(false)
 	require.NoError(t, err)
 	blockParts, err := block.MakePartSet(types.BlockPartSizeBytes)
 	require.NoError(t, err)
diff --git a/consensus/replay_test.go b/consensus/replay_test.go
index 9b267514a..b84911f5e 100644
--- a/consensus/replay_test.go
+++ b/consensus/replay_test.go
@@ -373,7 +373,7 @@ func TestSimulateValidatorsChange(t *testing.T) {
 	newValidatorTx1 := kvstore.MakeValSetChangeTx(valPubKey1ABCI, testMinPower)
 	err = assertMempool(css[0].txNotifier).CheckTx(newValidatorTx1, nil, mempl.TxInfo{})
 	assert.NoError(t, err)
-	propBlock, err := css[0].createProposalBlock() // changeProposer(t, cs1, vs2)
+	propBlock, err := css[0].createProposalBlock(false) // changeProposer(t, cs1, vs2)
 	require.NoError(t, err)
 	propBlockParts, err := propBlock.MakePartSet(partSize)
 	require.NoError(t, err)
@@ -405,7 +405,7 @@ func TestSimulateValidatorsChange(t *testing.T) {
 	updateValidatorTx1 := kvstore.MakeValSetChangeTx(updatePubKey1ABCI, 25)
 	err = assertMempool(css[0].txNotifier).CheckTx(updateValidatorTx1, nil, mempl.TxInfo{})
 	assert.NoError(t, err)
-	propBlock, err = css[0].createProposalBlock() // changeProposer(t, cs1, vs2)
+	propBlock, err = css[0].createProposalBlock(false) // changeProposer(t, cs1, vs2)
 	require.NoError(t, err)
 	propBlockParts, err = propBlock.MakePartSet(partSize)
 	require.NoError(t, err)
@@ -444,7 +444,7 @@ func TestSimulateValidatorsChange(t *testing.T) {
 	newValidatorTx3 := kvstore.MakeValSetChangeTx(newVal3ABCI, testMinPower)
 	err = assertMempool(css[0].txNotifier).CheckTx(newValidatorTx3, nil, mempl.TxInfo{})
 	assert.NoError(t, err)
-	propBlock, err = css[0].createProposalBlock() // changeProposer(t, cs1, vs2)
+	propBlock, err = css[0].createProposalBlock(false) // changeProposer(t, cs1, vs2)
 	require.NoError(t, err)
 	propBlockParts, err = propBlock.MakePartSet(partSize)
 	require.NoError(t, err)
@@ -521,7 +521,7 @@ func TestSimulateValidatorsChange(t *testing.T) {
 	removeValidatorTx3 := kvstore.MakeValSetChangeTx(newVal3ABCI, 0)
 	err = assertMempool(css[0].txNotifier).CheckTx(removeValidatorTx3, nil, mempl.TxInfo{})
 	assert.NoError(t, err)
-	propBlock, err = css[0].createProposalBlock() // changeProposer(t, cs1, vs2)
+	propBlock, err = css[0].createProposalBlock(false) // changeProposer(t, cs1, vs2)
 	require.NoError(t, err)
 	propBlockParts, err = propBlock.MakePartSet(partSize)
 	require.NoError(t, err)
diff --git a/consensus/state.go b/consensus/state.go
index da1205b82..e0d415552 100644
--- a/consensus/state.go
+++ b/consensus/state.go
@@ -127,7 +127,7 @@ type State struct {
 	nSteps int
 
 	// some functions can be overwritten for testing
-	decideProposal func(height int64, round int32)
+	decideProposal func(height int64, round int32, isNonProposingNode bool)
 	doPrevote      func(height int64, round int32)
 	setProposal    func(proposal *types.Proposal) error
 
@@ -1117,12 +1117,13 @@ func (cs *State) enterPropose(height int64, round int32) {
 	// if not a validator, we're done
 	if !cs.Validators.HasAddress(address) {
 		logger.Debug("node is not a validator", "addr", address, "vals", cs.Validators)
+		cs.decideProposal(height, round, true)
 		return
 	}
 
 	if cs.isProposer(address) {
 		logger.Debug("propose step; our turn to propose", "proposer", address)
-		cs.decideProposal(height, round)
+		cs.decideProposal(height, round, false)
 	} else {
 		logger.Debug("propose step; not our turn to propose", "proposer", cs.Validators.GetProposer().Address)
 	}
@@ -1132,10 +1133,23 @@ func (cs *State) isProposer(address []byte) bool {
 	return bytes.Equal(cs.Validators.GetProposer().Address, address)
 }
 
-func (cs *State) defaultDecideProposal(height int64, round int32) {
+func (cs *State) defaultDecideProposal(height int64, round int32, isNonProposingNode bool) {
 	var block *types.Block
 	var blockParts *types.PartSet
 
+	if isNonProposingNode {
+		// Create a new proposal block from state/txs from the mempool.
+		var err error
+		block, err = cs.createProposalBlock(isNonProposingNode)
+		if err != nil {
+			cs.Logger.Error("unable to create proposal block as a non-proposing node", "error", err)
+			return
+		} else if block == nil {
+			cs.Logger.Error("error", "error", "Method createProposalBlock should not provide a nil block without errors")
+		}
+		return
+	}
+
 	// Decide on block
 	if cs.ValidBlock != nil {
 		// If there is valid block, choose that.
@@ -1143,7 +1157,7 @@ func (cs *State) defaultDecideProposal(height int64, round int32) {
 	} else {
 		// Create a new proposal block from state/txs from the mempool.
 		var err error
-		block, err = cs.createProposalBlock()
+		block, err = cs.createProposalBlock(isNonProposingNode)
 		if err != nil {
 			cs.Logger.Error("unable to create proposal block", "error", err)
 			return
@@ -1207,7 +1221,16 @@ func (cs *State) isProposalComplete() bool {
 //
 // NOTE: keep it side-effect free for clarity.
 // CONTRACT: cs.privValidator is not nil.
-func (cs *State) createProposalBlock() (*types.Block, error) {
+func (cs *State) createProposalBlock(isNonProposingNode bool) (*types.Block, error) {
+
+	if isNonProposingNode {
+		ret, err := cs.blockExec.CreateProposalBlock(0, cs.state, nil, nil, isNonProposingNode)
+		if err != nil {
+			return ret, err
+		}
+		return ret, nil
+	}
+
 	if cs.privValidator == nil {
 		return nil, errors.New("entered createProposalBlock with privValidator being nil")
 	}
@@ -1235,7 +1258,7 @@ func (cs *State) createProposalBlock() (*types.Block, error) {
 
 	proposerAddr := cs.privValidatorPubKey.Address()
 
-	ret, err := cs.blockExec.CreateProposalBlock(cs.Height, cs.state, commit, proposerAddr)
+	ret, err := cs.blockExec.CreateProposalBlock(cs.Height, cs.state, commit, proposerAddr, isNonProposingNode)
 	if err != nil {
 		panic(err)
 	}
diff --git a/consensus/state_test.go b/consensus/state_test.go
index 01bfdbece..f1b8c0005 100644
--- a/consensus/state_test.go
+++ b/consensus/state_test.go
@@ -201,7 +201,7 @@ func TestStateBadProposal(t *testing.T) {
 	proposalCh := subscribe(cs1.eventBus, types.EventQueryCompleteProposal)
 	voteCh := subscribe(cs1.eventBus, types.EventQueryVote)
 
-	propBlock, err := cs1.createProposalBlock() // changeProposer(t, cs1, vs2)
+	propBlock, err := cs1.createProposalBlock(false) // changeProposer(t, cs1, vs2)
 	require.NoError(t, err)
 
 	// make the second validator the proposer by incrementing round
diff --git a/proto/dydxcometbft/clob/matches.pb.go b/proto/dydxcometbft/clob/matches.pb.go
index 63e7094f1..a69b77e72 100644
--- a/proto/dydxcometbft/clob/matches.pb.go
+++ b/proto/dydxcometbft/clob/matches.pb.go
@@ -7,7 +7,7 @@ import (
 	fmt "fmt"
 	subaccounts "github.com/cometbft/cometbft/proto/dydxcometbft/subaccounts"
 	_ "github.com/cosmos/gogoproto/gogoproto"
-	proto "github.com/cosmos/gogoproto/proto"
+	proto "github.com/gogo/protobuf/proto"
 	io "io"
 	math "math"
 	math_bits "math/bits"
diff --git a/proto/dydxcometbft/clob/order.pb.go b/proto/dydxcometbft/clob/order.pb.go
index c0ae3af2f..3bf24e5a9 100644
--- a/proto/dydxcometbft/clob/order.pb.go
+++ b/proto/dydxcometbft/clob/order.pb.go
@@ -8,7 +8,7 @@ import (
 	fmt "fmt"
 	subaccounts "github.com/cometbft/cometbft/proto/dydxcometbft/subaccounts"
 	_ "github.com/cosmos/gogoproto/gogoproto"
-	proto "github.com/cosmos/gogoproto/proto"
+	proto "github.com/gogo/protobuf/proto"
 	io "io"
 	math "math"
 	math_bits "math/bits"
@@ -491,7 +491,6 @@ type Order struct {
 	// Information about when the order expires.
 	//
 	// Types that are valid to be assigned to GoodTilOneof:
-	//
 	//	*Order_GoodTilBlock
 	//	*Order_GoodTilBlockTime
 	GoodTilOneof isOrder_GoodTilOneof `protobuf_oneof:"good_til_oneof"`
diff --git a/proto/dydxcometbft/clob/tx.pb.go b/proto/dydxcometbft/clob/tx.pb.go
index 137bb855a..cc36817cb 100644
--- a/proto/dydxcometbft/clob/tx.pb.go
+++ b/proto/dydxcometbft/clob/tx.pb.go
@@ -9,8 +9,7 @@ import (
 	fmt "fmt"
 	_ "github.com/cosmos/cosmos-proto"
 	_ "github.com/cosmos/gogoproto/gogoproto"
-	grpc1 "github.com/cosmos/gogoproto/grpc"
-	proto "github.com/cosmos/gogoproto/proto"
+	proto "github.com/gogo/protobuf/proto"
 	grpc "google.golang.org/grpc"
 	codes "google.golang.org/grpc/codes"
 	status "google.golang.org/grpc/status"
@@ -668,10 +667,10 @@ type MsgClient interface {
 }
 
 type msgClient struct {
-	cc grpc1.ClientConn
+	cc *grpc.ClientConn
 }
 
-func NewMsgClient(cc grpc1.ClientConn) MsgClient {
+func NewMsgClient(cc *grpc.ClientConn) MsgClient {
 	return &msgClient{cc}
 }
 
@@ -727,7 +726,7 @@ func (*UnimplementedMsgServer) CancelOrder(ctx context.Context, req *MsgCancelOr
 	return nil, status.Errorf(codes.Unimplemented, "method CancelOrder not implemented")
 }
 
-func RegisterMsgServer(s grpc1.Server, srv MsgServer) {
+func RegisterMsgServer(s *grpc.Server, srv MsgServer) {
 	s.RegisterService(&_Msg_serviceDesc, srv)
 }
 
diff --git a/proto/dydxcometbft/subaccounts/asset_position.pb.go b/proto/dydxcometbft/subaccounts/asset_position.pb.go
index e56d34d2f..dc399f653 100644
--- a/proto/dydxcometbft/subaccounts/asset_position.pb.go
+++ b/proto/dydxcometbft/subaccounts/asset_position.pb.go
@@ -7,7 +7,7 @@ import (
 	fmt "fmt"
 	github_com_cometbft_cometbft_proto_dydxcometbft_gotypes "github.com/cometbft/cometbft/proto/dydxcometbft/gotypes"
 	_ "github.com/cosmos/gogoproto/gogoproto"
-	proto "github.com/cosmos/gogoproto/proto"
+	proto "github.com/gogo/protobuf/proto"
 	io "io"
 	math "math"
 	math_bits "math/bits"
diff --git a/proto/dydxcometbft/subaccounts/perpetual_position.pb.go b/proto/dydxcometbft/subaccounts/perpetual_position.pb.go
index 372bb8e8d..d736c7ccf 100644
--- a/proto/dydxcometbft/subaccounts/perpetual_position.pb.go
+++ b/proto/dydxcometbft/subaccounts/perpetual_position.pb.go
@@ -7,7 +7,7 @@ import (
 	fmt "fmt"
 	github_com_cometbft_cometbft_proto_dydxcometbft_gotypes "github.com/cometbft/cometbft/proto/dydxcometbft/gotypes"
 	_ "github.com/cosmos/gogoproto/gogoproto"
-	proto "github.com/cosmos/gogoproto/proto"
+	proto "github.com/gogo/protobuf/proto"
 	io "io"
 	math "math"
 	math_bits "math/bits"
diff --git a/proto/dydxcometbft/subaccounts/subaccount.pb.go b/proto/dydxcometbft/subaccounts/subaccount.pb.go
index cce8b8e56..cf88b27a3 100644
--- a/proto/dydxcometbft/subaccounts/subaccount.pb.go
+++ b/proto/dydxcometbft/subaccounts/subaccount.pb.go
@@ -6,7 +6,7 @@ package subaccounts
 import (
 	fmt "fmt"
 	_ "github.com/cosmos/cosmos-proto"
-	proto "github.com/cosmos/gogoproto/proto"
+	proto "github.com/gogo/protobuf/proto"
 	io "io"
 	math "math"
 	math_bits "math/bits"
diff --git a/proto/tendermint/abci/types.proto b/proto/tendermint/abci/types.proto
index cf9927d79..2bad3fb66 100644
--- a/proto/tendermint/abci/types.proto
+++ b/proto/tendermint/abci/types.proto
@@ -134,6 +134,8 @@ message RequestPrepareProposal {
   bytes                     next_validators_hash = 7;
   // address of the public key of the validator proposing the block.
   bytes proposer_address = 8;
+  // true/false value if calling PrepareProposal as a non-proposing-node
+  bool is_non_proposing_node = 9;
 }
 
 message RequestProcessProposal {
diff --git a/proto/tendermint/blocksync/types.pb.go b/proto/tendermint/blocksync/types.pb.go
index b844990a2..404cef99b 100644
--- a/proto/tendermint/blocksync/types.pb.go
+++ b/proto/tendermint/blocksync/types.pb.go
@@ -6,7 +6,7 @@ package blocksync
 import (
 	fmt "fmt"
 	types "github.com/cometbft/cometbft/proto/tendermint/types"
-	proto "github.com/cosmos/gogoproto/proto"
+	proto "github.com/gogo/protobuf/proto"
 	io "io"
 	math "math"
 	math_bits "math/bits"
diff --git a/proto/tendermint/consensus/types.pb.go b/proto/tendermint/consensus/types.pb.go
index e23f0abdd..e492a34c8 100644
--- a/proto/tendermint/consensus/types.pb.go
+++ b/proto/tendermint/consensus/types.pb.go
@@ -8,7 +8,7 @@ import (
 	bits "github.com/cometbft/cometbft/proto/tendermint/libs/bits"
 	types "github.com/cometbft/cometbft/proto/tendermint/types"
 	_ "github.com/cosmos/gogoproto/gogoproto"
-	proto "github.com/cosmos/gogoproto/proto"
+	proto "github.com/gogo/protobuf/proto"
 	io "io"
 	math "math"
 	math_bits "math/bits"
diff --git a/proto/tendermint/consensus/wal.pb.go b/proto/tendermint/consensus/wal.pb.go
index f870835ef..62bd800cb 100644
--- a/proto/tendermint/consensus/wal.pb.go
+++ b/proto/tendermint/consensus/wal.pb.go
@@ -7,9 +7,9 @@ import (
 	fmt "fmt"
 	types "github.com/cometbft/cometbft/proto/tendermint/types"
 	_ "github.com/cosmos/gogoproto/gogoproto"
-	proto "github.com/cosmos/gogoproto/proto"
 	_ "github.com/cosmos/gogoproto/types"
-	github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types"
+	proto "github.com/gogo/protobuf/proto"
+	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
 	_ "github.com/golang/protobuf/ptypes/duration"
 	io "io"
 	math "math"
@@ -484,7 +484,7 @@ func (m *TimeoutInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x10
 	}
-	n2, err2 := github_com_cosmos_gogoproto_types.StdDurationMarshalTo(m.Duration, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.Duration):])
+	n2, err2 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.Duration, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.Duration):])
 	if err2 != nil {
 		return 0, err2
 	}
@@ -671,7 +671,7 @@ func (m *TimedWALMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x12
 	}
-	n8, err8 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Time):])
+	n8, err8 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Time):])
 	if err8 != nil {
 		return 0, err8
 	}
@@ -714,7 +714,7 @@ func (m *TimeoutInfo) Size() (n int) {
 	}
 	var l int
 	_ = l
-	l = github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.Duration)
+	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.Duration)
 	n += 1 + l + sovWal(uint64(l))
 	if m.Height != 0 {
 		n += 1 + sovWal(uint64(m.Height))
@@ -806,7 +806,7 @@ func (m *TimedWALMessage) Size() (n int) {
 	}
 	var l int
 	_ = l
-	l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Time)
+	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Time)
 	n += 1 + l + sovWal(uint64(l))
 	if m.Msg != nil {
 		l = m.Msg.Size()
@@ -994,7 +994,7 @@ func (m *TimeoutInfo) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := github_com_cosmos_gogoproto_types.StdDurationUnmarshal(&m.Duration, dAtA[iNdEx:postIndex]); err != nil {
+			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.Duration, dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -1393,7 +1393,7 @@ func (m *TimedWALMessage) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.Time, dAtA[iNdEx:postIndex]); err != nil {
+			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Time, dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
diff --git a/proto/tendermint/crypto/keys.pb.go b/proto/tendermint/crypto/keys.pb.go
index 0edb2269f..0218a4d54 100644
--- a/proto/tendermint/crypto/keys.pb.go
+++ b/proto/tendermint/crypto/keys.pb.go
@@ -7,7 +7,7 @@ import (
 	bytes "bytes"
 	fmt "fmt"
 	_ "github.com/cosmos/gogoproto/gogoproto"
-	proto "github.com/cosmos/gogoproto/proto"
+	proto "github.com/gogo/protobuf/proto"
 	io "io"
 	math "math"
 	math_bits "math/bits"
@@ -27,7 +27,6 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 // PublicKey defines the keys available for use with Validators
 type PublicKey struct {
 	// Types that are valid to be assigned to Sum:
-	//
 	//	*PublicKey_Ed25519
 	//	*PublicKey_Secp256K1
 	Sum isPublicKey_Sum `protobuf_oneof:"sum"`
diff --git a/proto/tendermint/crypto/proof.pb.go b/proto/tendermint/crypto/proof.pb.go
index 1c2273a74..e7c1cfed8 100644
--- a/proto/tendermint/crypto/proof.pb.go
+++ b/proto/tendermint/crypto/proof.pb.go
@@ -6,7 +6,7 @@ package crypto
 import (
 	fmt "fmt"
 	_ "github.com/cosmos/gogoproto/gogoproto"
-	proto "github.com/cosmos/gogoproto/proto"
+	proto "github.com/gogo/protobuf/proto"
 	io "io"
 	math "math"
 	math_bits "math/bits"
diff --git a/proto/tendermint/libs/bits/types.pb.go b/proto/tendermint/libs/bits/types.pb.go
index 9dc377336..29fe10c76 100644
--- a/proto/tendermint/libs/bits/types.pb.go
+++ b/proto/tendermint/libs/bits/types.pb.go
@@ -5,7 +5,7 @@ package bits
 
 import (
 	fmt "fmt"
-	proto "github.com/cosmos/gogoproto/proto"
+	proto "github.com/gogo/protobuf/proto"
 	io "io"
 	math "math"
 	math_bits "math/bits"
diff --git a/proto/tendermint/mempool/types.pb.go b/proto/tendermint/mempool/types.pb.go
index 4a6a40ef3..6e984a008 100644
--- a/proto/tendermint/mempool/types.pb.go
+++ b/proto/tendermint/mempool/types.pb.go
@@ -5,7 +5,7 @@ package mempool
 
 import (
 	fmt "fmt"
-	proto "github.com/cosmos/gogoproto/proto"
+	proto "github.com/gogo/protobuf/proto"
 	io "io"
 	math "math"
 	math_bits "math/bits"
@@ -68,7 +68,6 @@ func (m *Txs) GetTxs() [][]byte {
 
 type Message struct {
 	// Types that are valid to be assigned to Sum:
-	//
 	//	*Message_Txs
 	Sum isMessage_Sum `protobuf_oneof:"sum"`
 }
diff --git a/proto/tendermint/p2p/conn.pb.go b/proto/tendermint/p2p/conn.pb.go
index 4a0f82564..35cc24f6d 100644
--- a/proto/tendermint/p2p/conn.pb.go
+++ b/proto/tendermint/p2p/conn.pb.go
@@ -7,7 +7,7 @@ import (
 	fmt "fmt"
 	crypto "github.com/cometbft/cometbft/proto/tendermint/crypto"
 	_ "github.com/cosmos/gogoproto/gogoproto"
-	proto "github.com/cosmos/gogoproto/proto"
+	proto "github.com/gogo/protobuf/proto"
 	io "io"
 	math "math"
 	math_bits "math/bits"
@@ -158,7 +158,6 @@ func (m *PacketMsg) GetData() []byte {
 
 type Packet struct {
 	// Types that are valid to be assigned to Sum:
-	//
 	//	*Packet_PacketPing
 	//	*Packet_PacketPong
 	//	*Packet_PacketMsg
diff --git a/proto/tendermint/p2p/pex.pb.go b/proto/tendermint/p2p/pex.pb.go
index d8dcb94ad..327874535 100644
--- a/proto/tendermint/p2p/pex.pb.go
+++ b/proto/tendermint/p2p/pex.pb.go
@@ -6,7 +6,7 @@ package p2p
 import (
 	fmt "fmt"
 	_ "github.com/cosmos/gogoproto/gogoproto"
-	proto "github.com/cosmos/gogoproto/proto"
+	proto "github.com/gogo/protobuf/proto"
 	io "io"
 	math "math"
 	math_bits "math/bits"
diff --git a/proto/tendermint/p2p/types.pb.go b/proto/tendermint/p2p/types.pb.go
index 9de144b34..9c9402c20 100644
--- a/proto/tendermint/p2p/types.pb.go
+++ b/proto/tendermint/p2p/types.pb.go
@@ -6,7 +6,7 @@ package p2p
 import (
 	fmt "fmt"
 	_ "github.com/cosmos/gogoproto/gogoproto"
-	proto "github.com/cosmos/gogoproto/proto"
+	proto "github.com/gogo/protobuf/proto"
 	io "io"
 	math "math"
 	math_bits "math/bits"
diff --git a/proto/tendermint/privval/types.pb.go b/proto/tendermint/privval/types.pb.go
index cafa0e927..f983c8490 100644
--- a/proto/tendermint/privval/types.pb.go
+++ b/proto/tendermint/privval/types.pb.go
@@ -8,7 +8,7 @@ import (
 	crypto "github.com/cometbft/cometbft/proto/tendermint/crypto"
 	types "github.com/cometbft/cometbft/proto/tendermint/types"
 	_ "github.com/cosmos/gogoproto/gogoproto"
-	proto "github.com/cosmos/gogoproto/proto"
+	proto "github.com/gogo/protobuf/proto"
 	io "io"
 	math "math"
 	math_bits "math/bits"
diff --git a/proto/tendermint/rpc/grpc/types.pb.go b/proto/tendermint/rpc/grpc/types.pb.go
index d52c53869..d61c39e9e 100644
--- a/proto/tendermint/rpc/grpc/types.pb.go
+++ b/proto/tendermint/rpc/grpc/types.pb.go
@@ -7,8 +7,7 @@ import (
 	context "context"
 	fmt "fmt"
 	types "github.com/cometbft/cometbft/abci/types"
-	grpc1 "github.com/cosmos/gogoproto/grpc"
-	proto "github.com/cosmos/gogoproto/proto"
+	proto "github.com/gogo/protobuf/proto"
 	grpc "google.golang.org/grpc"
 	codes "google.golang.org/grpc/codes"
 	status "google.golang.org/grpc/status"
@@ -247,10 +246,10 @@ type BroadcastAPIClient interface {
 }
 
 type broadcastAPIClient struct {
-	cc grpc1.ClientConn
+	cc *grpc.ClientConn
 }
 
-func NewBroadcastAPIClient(cc grpc1.ClientConn) BroadcastAPIClient {
+func NewBroadcastAPIClient(cc *grpc.ClientConn) BroadcastAPIClient {
 	return &broadcastAPIClient{cc}
 }
 
@@ -289,7 +288,7 @@ func (*UnimplementedBroadcastAPIServer) BroadcastTx(ctx context.Context, req *Re
 	return nil, status.Errorf(codes.Unimplemented, "method BroadcastTx not implemented")
 }
 
-func RegisterBroadcastAPIServer(s grpc1.Server, srv BroadcastAPIServer) {
+func RegisterBroadcastAPIServer(s *grpc.Server, srv BroadcastAPIServer) {
 	s.RegisterService(&_BroadcastAPI_serviceDesc, srv)
 }
 
diff --git a/proto/tendermint/state/types.pb.go b/proto/tendermint/state/types.pb.go
index ab9478718..b9d3b9ced 100644
--- a/proto/tendermint/state/types.pb.go
+++ b/proto/tendermint/state/types.pb.go
@@ -9,9 +9,9 @@ import (
 	types1 "github.com/cometbft/cometbft/proto/tendermint/types"
 	version "github.com/cometbft/cometbft/proto/tendermint/version"
 	_ "github.com/cosmos/gogoproto/gogoproto"
-	proto "github.com/cosmos/gogoproto/proto"
 	_ "github.com/cosmos/gogoproto/types"
-	github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types"
+	proto "github.com/gogo/protobuf/proto"
+	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
 	io "io"
 	math "math"
 	math_bits "math/bits"
@@ -843,7 +843,7 @@ func (m *State) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x32
 	}
-	n11, err11 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.LastBlockTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.LastBlockTime):])
+	n11, err11 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.LastBlockTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.LastBlockTime):])
 	if err11 != nil {
 		return 0, err11
 	}
@@ -998,7 +998,7 @@ func (m *State) Size() (n int) {
 	}
 	l = m.LastBlockID.Size()
 	n += 1 + l + sovTypes(uint64(l))
-	l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.LastBlockTime)
+	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.LastBlockTime)
 	n += 1 + l + sovTypes(uint64(l))
 	if m.NextValidators != nil {
 		l = m.NextValidators.Size()
@@ -1798,7 +1798,7 @@ func (m *State) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.LastBlockTime, dAtA[iNdEx:postIndex]); err != nil {
+			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.LastBlockTime, dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
diff --git a/proto/tendermint/statesync/types.pb.go b/proto/tendermint/statesync/types.pb.go
index 84a637f5e..348a5752b 100644
--- a/proto/tendermint/statesync/types.pb.go
+++ b/proto/tendermint/statesync/types.pb.go
@@ -5,7 +5,7 @@ package statesync
 
 import (
 	fmt "fmt"
-	proto "github.com/cosmos/gogoproto/proto"
+	proto "github.com/gogo/protobuf/proto"
 	io "io"
 	math "math"
 	math_bits "math/bits"
@@ -24,7 +24,6 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 
 type Message struct {
 	// Types that are valid to be assigned to Sum:
-	//
 	//	*Message_SnapshotsRequest
 	//	*Message_SnapshotsResponse
 	//	*Message_ChunkRequest
diff --git a/proto/tendermint/store/types.pb.go b/proto/tendermint/store/types.pb.go
index e7e553e0e..ce29389f5 100644
--- a/proto/tendermint/store/types.pb.go
+++ b/proto/tendermint/store/types.pb.go
@@ -5,7 +5,7 @@ package store
 
 import (
 	fmt "fmt"
-	proto "github.com/cosmos/gogoproto/proto"
+	proto "github.com/gogo/protobuf/proto"
 	io "io"
 	math "math"
 	math_bits "math/bits"
diff --git a/proto/tendermint/types/block.pb.go b/proto/tendermint/types/block.pb.go
index 3b3e3811f..fde7a3bc7 100644
--- a/proto/tendermint/types/block.pb.go
+++ b/proto/tendermint/types/block.pb.go
@@ -6,7 +6,7 @@ package types
 import (
 	fmt "fmt"
 	_ "github.com/cosmos/gogoproto/gogoproto"
-	proto "github.com/cosmos/gogoproto/proto"
+	proto "github.com/gogo/protobuf/proto"
 	io "io"
 	math "math"
 	math_bits "math/bits"
diff --git a/proto/tendermint/types/canonical.pb.go b/proto/tendermint/types/canonical.pb.go
index c79cf92d2..21d17d31b 100644
--- a/proto/tendermint/types/canonical.pb.go
+++ b/proto/tendermint/types/canonical.pb.go
@@ -7,9 +7,9 @@ import (
 	encoding_binary "encoding/binary"
 	fmt "fmt"
 	_ "github.com/cosmos/gogoproto/gogoproto"
-	proto "github.com/cosmos/gogoproto/proto"
 	_ "github.com/cosmos/gogoproto/types"
-	github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types"
+	proto "github.com/gogo/protobuf/proto"
+	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
 	io "io"
 	math "math"
 	math_bits "math/bits"
@@ -454,7 +454,7 @@ func (m *CanonicalProposal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x3a
 	}
-	n2, err2 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Timestamp):])
+	n2, err2 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp):])
 	if err2 != nil {
 		return 0, err2
 	}
@@ -526,7 +526,7 @@ func (m *CanonicalVote) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x32
 	}
-	n4, err4 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Timestamp):])
+	n4, err4 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp):])
 	if err4 != nil {
 		return 0, err4
 	}
@@ -630,7 +630,7 @@ func (m *CanonicalProposal) Size() (n int) {
 		l = m.BlockID.Size()
 		n += 1 + l + sovCanonical(uint64(l))
 	}
-	l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Timestamp)
+	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp)
 	n += 1 + l + sovCanonical(uint64(l))
 	l = len(m.ChainID)
 	if l > 0 {
@@ -658,7 +658,7 @@ func (m *CanonicalVote) Size() (n int) {
 		l = m.BlockID.Size()
 		n += 1 + l + sovCanonical(uint64(l))
 	}
-	l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Timestamp)
+	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp)
 	n += 1 + l + sovCanonical(uint64(l))
 	l = len(m.ChainID)
 	if l > 0 {
@@ -1045,7 +1045,7 @@ func (m *CanonicalProposal) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.Timestamp, dAtA[iNdEx:postIndex]); err != nil {
+			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Timestamp, dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -1235,7 +1235,7 @@ func (m *CanonicalVote) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.Timestamp, dAtA[iNdEx:postIndex]); err != nil {
+			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Timestamp, dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
diff --git a/proto/tendermint/types/events.pb.go b/proto/tendermint/types/events.pb.go
index 02607e6d9..1f210e37f 100644
--- a/proto/tendermint/types/events.pb.go
+++ b/proto/tendermint/types/events.pb.go
@@ -5,7 +5,7 @@ package types
 
 import (
 	fmt "fmt"
-	proto "github.com/cosmos/gogoproto/proto"
+	proto "github.com/gogo/protobuf/proto"
 	io "io"
 	math "math"
 	math_bits "math/bits"
diff --git a/proto/tendermint/types/evidence.pb.go b/proto/tendermint/types/evidence.pb.go
index 1022d4daf..8da2ebfd5 100644
--- a/proto/tendermint/types/evidence.pb.go
+++ b/proto/tendermint/types/evidence.pb.go
@@ -6,9 +6,9 @@ package types
 import (
 	fmt "fmt"
 	_ "github.com/cosmos/gogoproto/gogoproto"
-	proto "github.com/cosmos/gogoproto/proto"
 	_ "github.com/cosmos/gogoproto/types"
-	github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types"
+	proto "github.com/gogo/protobuf/proto"
+	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
 	io "io"
 	math "math"
 	math_bits "math/bits"
@@ -451,7 +451,7 @@ func (m *DuplicateVoteEvidence) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	n3, err3 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Timestamp):])
+	n3, err3 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp):])
 	if err3 != nil {
 		return 0, err3
 	}
@@ -516,7 +516,7 @@ func (m *LightClientAttackEvidence) MarshalToSizedBuffer(dAtA []byte) (int, erro
 	_ = i
 	var l int
 	_ = l
-	n6, err6 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Timestamp):])
+	n6, err6 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp):])
 	if err6 != nil {
 		return 0, err6
 	}
@@ -667,7 +667,7 @@ func (m *DuplicateVoteEvidence) Size() (n int) {
 	if m.ValidatorPower != 0 {
 		n += 1 + sovEvidence(uint64(m.ValidatorPower))
 	}
-	l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Timestamp)
+	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp)
 	n += 1 + l + sovEvidence(uint64(l))
 	return n
 }
@@ -694,7 +694,7 @@ func (m *LightClientAttackEvidence) Size() (n int) {
 	if m.TotalVotingPower != 0 {
 		n += 1 + sovEvidence(uint64(m.TotalVotingPower))
 	}
-	l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Timestamp)
+	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp)
 	n += 1 + l + sovEvidence(uint64(l))
 	return n
 }
@@ -1008,7 +1008,7 @@ func (m *DuplicateVoteEvidence) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.Timestamp, dAtA[iNdEx:postIndex]); err != nil {
+			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Timestamp, dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -1199,7 +1199,7 @@ func (m *LightClientAttackEvidence) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.Timestamp, dAtA[iNdEx:postIndex]); err != nil {
+			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Timestamp, dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
diff --git a/proto/tendermint/types/params.pb.go b/proto/tendermint/types/params.pb.go
index 3990bb6e9..21bb01a12 100644
--- a/proto/tendermint/types/params.pb.go
+++ b/proto/tendermint/types/params.pb.go
@@ -6,8 +6,8 @@ package types
 import (
 	fmt "fmt"
 	_ "github.com/cosmos/gogoproto/gogoproto"
-	proto "github.com/cosmos/gogoproto/proto"
-	github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types"
+	proto "github.com/gogo/protobuf/proto"
+	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
 	_ "github.com/golang/protobuf/ptypes/duration"
 	io "io"
 	math "math"
@@ -720,7 +720,7 @@ func (m *EvidenceParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x18
 	}
-	n5, err5 := github_com_cosmos_gogoproto_types.StdDurationMarshalTo(m.MaxAgeDuration, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.MaxAgeDuration):])
+	n5, err5 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.MaxAgeDuration, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.MaxAgeDuration):])
 	if err5 != nil {
 		return 0, err5
 	}
@@ -981,7 +981,7 @@ func (m *EvidenceParams) Size() (n int) {
 	if m.MaxAgeNumBlocks != 0 {
 		n += 1 + sovParams(uint64(m.MaxAgeNumBlocks))
 	}
-	l = github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.MaxAgeDuration)
+	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.MaxAgeDuration)
 	n += 1 + l + sovParams(uint64(l))
 	if m.MaxBytes != 0 {
 		n += 1 + sovParams(uint64(m.MaxBytes))
@@ -1396,7 +1396,7 @@ func (m *EvidenceParams) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := github_com_cosmos_gogoproto_types.StdDurationUnmarshal(&m.MaxAgeDuration, dAtA[iNdEx:postIndex]); err != nil {
+			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.MaxAgeDuration, dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
diff --git a/proto/tendermint/types/types.pb.go b/proto/tendermint/types/types.pb.go
index ce6844bad..1f37db80b 100644
--- a/proto/tendermint/types/types.pb.go
+++ b/proto/tendermint/types/types.pb.go
@@ -8,9 +8,9 @@ import (
 	crypto "github.com/cometbft/cometbft/proto/tendermint/crypto"
 	version "github.com/cometbft/cometbft/proto/tendermint/version"
 	_ "github.com/cosmos/gogoproto/gogoproto"
-	proto "github.com/cosmos/gogoproto/proto"
 	_ "github.com/cosmos/gogoproto/types"
-	github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types"
+	proto "github.com/gogo/protobuf/proto"
+	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
 	io "io"
 	math "math"
 	math_bits "math/bits"
@@ -1348,7 +1348,7 @@ func (m *Header) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	}
 	i--
 	dAtA[i] = 0x2a
-	n4, err4 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Time):])
+	n4, err4 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Time):])
 	if err4 != nil {
 		return 0, err4
 	}
@@ -1452,7 +1452,7 @@ func (m *Vote) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x32
 	}
-	n6, err6 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Timestamp):])
+	n6, err6 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp):])
 	if err6 != nil {
 		return 0, err6
 	}
@@ -1572,7 +1572,7 @@ func (m *CommitSig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x22
 	}
-	n9, err9 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Timestamp):])
+	n9, err9 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp):])
 	if err9 != nil {
 		return 0, err9
 	}
@@ -1622,7 +1622,7 @@ func (m *Proposal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x3a
 	}
-	n10, err10 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Timestamp):])
+	n10, err10 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp):])
 	if err10 != nil {
 		return 0, err10
 	}
@@ -1934,7 +1934,7 @@ func (m *Header) Size() (n int) {
 	if m.Height != 0 {
 		n += 1 + sovTypes(uint64(m.Height))
 	}
-	l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Time)
+	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Time)
 	n += 1 + l + sovTypes(uint64(l))
 	l = m.LastBlockId.Size()
 	n += 1 + l + sovTypes(uint64(l))
@@ -2009,7 +2009,7 @@ func (m *Vote) Size() (n int) {
 	}
 	l = m.BlockID.Size()
 	n += 1 + l + sovTypes(uint64(l))
-	l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Timestamp)
+	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp)
 	n += 1 + l + sovTypes(uint64(l))
 	l = len(m.ValidatorAddress)
 	if l > 0 {
@@ -2061,7 +2061,7 @@ func (m *CommitSig) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovTypes(uint64(l))
 	}
-	l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Timestamp)
+	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp)
 	n += 1 + l + sovTypes(uint64(l))
 	l = len(m.Signature)
 	if l > 0 {
@@ -2090,7 +2090,7 @@ func (m *Proposal) Size() (n int) {
 	}
 	l = m.BlockID.Size()
 	n += 1 + l + sovTypes(uint64(l))
-	l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Timestamp)
+	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp)
 	n += 1 + l + sovTypes(uint64(l))
 	l = len(m.Signature)
 	if l > 0 {
@@ -2677,7 +2677,7 @@ func (m *Header) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.Time, dAtA[iNdEx:postIndex]); err != nil {
+			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Time, dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -3271,7 +3271,7 @@ func (m *Vote) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.Timestamp, dAtA[iNdEx:postIndex]); err != nil {
+			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Timestamp, dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -3649,7 +3649,7 @@ func (m *CommitSig) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.Timestamp, dAtA[iNdEx:postIndex]); err != nil {
+			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Timestamp, dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -3875,7 +3875,7 @@ func (m *Proposal) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.Timestamp, dAtA[iNdEx:postIndex]); err != nil {
+			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Timestamp, dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
diff --git a/proto/tendermint/types/validator.pb.go b/proto/tendermint/types/validator.pb.go
index df2307bfe..7e9784205 100644
--- a/proto/tendermint/types/validator.pb.go
+++ b/proto/tendermint/types/validator.pb.go
@@ -7,7 +7,7 @@ import (
 	fmt "fmt"
 	crypto "github.com/cometbft/cometbft/proto/tendermint/crypto"
 	_ "github.com/cosmos/gogoproto/gogoproto"
-	proto "github.com/cosmos/gogoproto/proto"
+	proto "github.com/gogo/protobuf/proto"
 	io "io"
 	math "math"
 	math_bits "math/bits"
diff --git a/proto/tendermint/version/types.pb.go b/proto/tendermint/version/types.pb.go
index f7393bf90..561818cb3 100644
--- a/proto/tendermint/version/types.pb.go
+++ b/proto/tendermint/version/types.pb.go
@@ -6,7 +6,7 @@ package version
 import (
 	fmt "fmt"
 	_ "github.com/cosmos/gogoproto/gogoproto"
-	proto "github.com/cosmos/gogoproto/proto"
+	proto "github.com/gogo/protobuf/proto"
 	io "io"
 	math "math"
 	math_bits "math/bits"
diff --git a/rpc/grpc/types.pb.go b/rpc/grpc/types.pb.go
index d52c53869..d61c39e9e 100644
--- a/rpc/grpc/types.pb.go
+++ b/rpc/grpc/types.pb.go
@@ -7,8 +7,7 @@ import (
 	context "context"
 	fmt "fmt"
 	types "github.com/cometbft/cometbft/abci/types"
-	grpc1 "github.com/cosmos/gogoproto/grpc"
-	proto "github.com/cosmos/gogoproto/proto"
+	proto "github.com/gogo/protobuf/proto"
 	grpc "google.golang.org/grpc"
 	codes "google.golang.org/grpc/codes"
 	status "google.golang.org/grpc/status"
@@ -247,10 +246,10 @@ type BroadcastAPIClient interface {
 }
 
 type broadcastAPIClient struct {
-	cc grpc1.ClientConn
+	cc *grpc.ClientConn
 }
 
-func NewBroadcastAPIClient(cc grpc1.ClientConn) BroadcastAPIClient {
+func NewBroadcastAPIClient(cc *grpc.ClientConn) BroadcastAPIClient {
 	return &broadcastAPIClient{cc}
 }
 
@@ -289,7 +288,7 @@ func (*UnimplementedBroadcastAPIServer) BroadcastTx(ctx context.Context, req *Re
 	return nil, status.Errorf(codes.Unimplemented, "method BroadcastTx not implemented")
 }
 
-func RegisterBroadcastAPIServer(s grpc1.Server, srv BroadcastAPIServer) {
+func RegisterBroadcastAPIServer(s *grpc.Server, srv BroadcastAPIServer) {
 	s.RegisterService(&_BroadcastAPI_serviceDesc, srv)
 }
 
diff --git a/state/execution.go b/state/execution.go
index 5fb6b3337..bdfcfe687 100644
--- a/state/execution.go
+++ b/state/execution.go
@@ -97,6 +97,7 @@ func (blockExec *BlockExecutor) CreateProposalBlock(
 	state State,
 	commit *types.Commit,
 	proposerAddr []byte,
+	isNonProposingNode bool,
 ) (*types.Block, error) {
 
 	maxBytes := state.ConsensusParams.Block.MaxBytes
@@ -108,6 +109,27 @@ func (blockExec *BlockExecutor) CreateProposalBlock(
 	maxDataBytes := types.MaxDataBytes(maxBytes, evSize, state.Validators.Size())
 
 	txs := blockExec.mempool.ReapMaxBytesMaxGas(maxDataBytes, maxGas)
+
+	if isNonProposingNode {
+		_, err := blockExec.proxyApp.PrepareProposalSync(
+			abci.RequestPrepareProposal{
+				MaxTxBytes:         maxDataBytes,
+				Txs:                nil,
+				LocalLastCommit:    abci.ExtendedCommitInfo{},
+				Misbehavior:        nil,
+				Height:             0,
+				Time:               time.Time{},
+				NextValidatorsHash: nil,
+				ProposerAddress:    nil,
+				IsNonProposingNode: true,
+			},
+		)
+		if err != nil {
+			return nil, err
+		}
+		return nil, nil
+	}
+
 	block := state.MakeBlock(height, txs, commit, evidence, proposerAddr)
 
 	localLastCommit := buildLastCommitInfo(block, blockExec.store, state.InitialHeight)
@@ -121,6 +143,7 @@ func (blockExec *BlockExecutor) CreateProposalBlock(
 			Time:               block.Time,
 			NextValidatorsHash: block.NextValidatorsHash,
 			ProposerAddress:    block.ProposerAddress,
+			IsNonProposingNode: false,
 		},
 	)
 	if err != nil {
diff --git a/state/execution_test.go b/state/execution_test.go
index 23a602606..1d91d6b24 100644
--- a/state/execution_test.go
+++ b/state/execution_test.go
@@ -631,7 +631,7 @@ func TestEmptyPrepareProposal(t *testing.T) {
 	pa, _ := state.Validators.GetByIndex(0)
 	commit, err := makeValidCommit(height, types.BlockID{}, state.Validators, privVals)
 	require.NoError(t, err)
-	_, err = blockExec.CreateProposalBlock(height, state, commit, pa)
+	_, err = blockExec.CreateProposalBlock(height, state, commit, pa, false)
 	require.NoError(t, err)
 }
 
@@ -672,7 +672,7 @@ func TestPrepareProposalTxsAllIncluded(t *testing.T) {
 	pa, _ := state.Validators.GetByIndex(0)
 	commit, err := makeValidCommit(height, types.BlockID{}, state.Validators, privVals)
 	require.NoError(t, err)
-	block, err := blockExec.CreateProposalBlock(height, state, commit, pa)
+	block, err := blockExec.CreateProposalBlock(height, state, commit, pa, false)
 	require.NoError(t, err)
 
 	for i, tx := range block.Data.Txs {
@@ -723,7 +723,7 @@ func TestPrepareProposalReorderTxs(t *testing.T) {
 	pa, _ := state.Validators.GetByIndex(0)
 	commit, err := makeValidCommit(height, types.BlockID{}, state.Validators, privVals)
 	require.NoError(t, err)
-	block, err := blockExec.CreateProposalBlock(height, state, commit, pa)
+	block, err := blockExec.CreateProposalBlock(height, state, commit, pa, false)
 	require.NoError(t, err)
 	for i, tx := range block.Data.Txs {
 		require.Equal(t, txs[i], tx)
@@ -776,7 +776,7 @@ func TestPrepareProposalErrorOnTooManyTxs(t *testing.T) {
 	commit, err := makeValidCommit(height, types.BlockID{}, state.Validators, privVals)
 	require.NoError(t, err)
 
-	block, err := blockExec.CreateProposalBlock(height, state, commit, pa)
+	block, err := blockExec.CreateProposalBlock(height, state, commit, pa, false)
 	require.Nil(t, block)
 	require.ErrorContains(t, err, "transaction data size exceeds maximum")
 
@@ -824,7 +824,7 @@ func TestPrepareProposalErrorOnPrepareProposalError(t *testing.T) {
 	commit, err := makeValidCommit(height, types.BlockID{}, state.Validators, privVals)
 	require.NoError(t, err)
 
-	block, err := blockExec.CreateProposalBlock(height, state, commit, pa)
+	block, err := blockExec.CreateProposalBlock(height, state, commit, pa, false)
 	require.Nil(t, block)
 	require.ErrorContains(t, err, "an injected error")