diff --git a/proto/tendermint/blocksync/types.proto b/proto/tendermint/blocksync/types.proto
index 00f6db362..8ebe34574 100644
--- a/proto/tendermint/blocksync/types.proto
+++ b/proto/tendermint/blocksync/types.proto
@@ -18,7 +18,7 @@ message NoBlockResponse {
 
 // BlockResponse returns block to the requested
 message BlockResponse {
-  tendermint.types.Block block = 1;
+  tendermint.types.Block          block      = 1;
   tendermint.types.ExtendedCommit ext_commit = 2;
 }
 
diff --git a/proto/tendermint/types/params.pb.go b/proto/tendermint/types/params.pb.go
index 3d57b852c..1b2f2089c 100644
--- a/proto/tendermint/types/params.pb.go
+++ b/proto/tendermint/types/params.pb.go
@@ -34,6 +34,7 @@ type ConsensusParams struct {
 	Evidence  *EvidenceParams  `protobuf:"bytes,2,opt,name=evidence,proto3" json:"evidence,omitempty"`
 	Validator *ValidatorParams `protobuf:"bytes,3,opt,name=validator,proto3" json:"validator,omitempty"`
 	Version   *VersionParams   `protobuf:"bytes,4,opt,name=version,proto3" json:"version,omitempty"`
+	Abci      *ABCIParams      `protobuf:"bytes,5,opt,name=abci,proto3" json:"abci,omitempty"`
 }
 
 func (m *ConsensusParams) Reset()         { *m = ConsensusParams{} }
@@ -97,6 +98,13 @@ func (m *ConsensusParams) GetVersion() *VersionParams {
 	return nil
 }
 
+func (m *ConsensusParams) GetAbci() *ABCIParams {
+	if m != nil {
+		return m.Abci
+	}
+	return nil
+}
+
 // BlockParams contains limits on the block size.
 type BlockParams struct {
 	// Max block size, in bytes.
@@ -373,6 +381,60 @@ func (m *HashedParams) GetBlockMaxGas() int64 {
 	return 0
 }
 
+// ABCIParams configure functionality specific to the Application Blockchain Interface.
+type ABCIParams struct {
+	// vote_extensions_enable_height configures the first height during which
+	// vote extensions will be enabled. During this specified height, and for all
+	// subsequent heights, precommit messages that do not contain valid extension data
+	// will be considered invalid. Prior to this height, vote extensions will not
+	// be used or accepted by validators on the network.
+	//
+	// Once enabled, vote extensions will be created by the application in ExtendVote,
+	// passed to the application for validation in VerifyVoteExtension and given
+	// to the application to use when proposing a block during PrepareProposal.
+	VoteExtensionsEnableHeight int64 `protobuf:"varint,1,opt,name=vote_extensions_enable_height,json=voteExtensionsEnableHeight,proto3" json:"vote_extensions_enable_height,omitempty"`
+}
+
+func (m *ABCIParams) Reset()         { *m = ABCIParams{} }
+func (m *ABCIParams) String() string { return proto.CompactTextString(m) }
+func (*ABCIParams) ProtoMessage()    {}
+func (*ABCIParams) Descriptor() ([]byte, []int) {
+	return fileDescriptor_e12598271a686f57, []int{6}
+}
+func (m *ABCIParams) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *ABCIParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_ABCIParams.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *ABCIParams) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ABCIParams.Merge(m, src)
+}
+func (m *ABCIParams) XXX_Size() int {
+	return m.Size()
+}
+func (m *ABCIParams) XXX_DiscardUnknown() {
+	xxx_messageInfo_ABCIParams.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ABCIParams proto.InternalMessageInfo
+
+func (m *ABCIParams) GetVoteExtensionsEnableHeight() int64 {
+	if m != nil {
+		return m.VoteExtensionsEnableHeight
+	}
+	return 0
+}
+
 func init() {
 	proto.RegisterType((*ConsensusParams)(nil), "tendermint.types.ConsensusParams")
 	proto.RegisterType((*BlockParams)(nil), "tendermint.types.BlockParams")
@@ -380,45 +442,49 @@ func init() {
 	proto.RegisterType((*ValidatorParams)(nil), "tendermint.types.ValidatorParams")
 	proto.RegisterType((*VersionParams)(nil), "tendermint.types.VersionParams")
 	proto.RegisterType((*HashedParams)(nil), "tendermint.types.HashedParams")
+	proto.RegisterType((*ABCIParams)(nil), "tendermint.types.ABCIParams")
 }
 
 func init() { proto.RegisterFile("tendermint/types/params.proto", fileDescriptor_e12598271a686f57) }
 
 var fileDescriptor_e12598271a686f57 = []byte{
-	// 513 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x93, 0x4f, 0x6f, 0xd3, 0x30,
-	0x18, 0xc6, 0xeb, 0xa5, 0x6c, 0xed, 0x5b, 0xba, 0x56, 0x16, 0x12, 0x61, 0x68, 0x49, 0xc9, 0x01,
-	0x4d, 0x9a, 0x94, 0x48, 0xec, 0x80, 0x40, 0x48, 0x13, 0x05, 0x34, 0xfe, 0x68, 0x08, 0x45, 0xc0,
-	0x61, 0x97, 0xc8, 0x69, 0x4c, 0x16, 0xad, 0x8e, 0xa3, 0x38, 0xa9, 0xda, 0x1b, 0x1f, 0x81, 0x23,
-	0xc7, 0x1d, 0xe1, 0x1b, 0xf0, 0x11, 0x76, 0xdc, 0x91, 0x13, 0xa0, 0xf6, 0xc2, 0xc7, 0x40, 0x71,
-	0x62, 0xd2, 0x76, 0xbb, 0x39, 0x7e, 0x7e, 0x8f, 0x9d, 0xe7, 0xb1, 0x5e, 0xd8, 0xcd, 0x68, 0x1c,
-	0xd0, 0x94, 0x45, 0x71, 0xe6, 0x64, 0xb3, 0x84, 0x0a, 0x27, 0x21, 0x29, 0x61, 0xc2, 0x4e, 0x52,
-	0x9e, 0x71, 0xdc, 0xaf, 0x65, 0x5b, 0xca, 0x3b, 0xb7, 0x42, 0x1e, 0x72, 0x29, 0x3a, 0xc5, 0xaa,
-	0xe4, 0x76, 0x8c, 0x90, 0xf3, 0x70, 0x4c, 0x1d, 0xf9, 0xe5, 0xe7, 0x9f, 0x9c, 0x20, 0x4f, 0x49,
-	0x16, 0xf1, 0xb8, 0xd4, 0xad, 0xcf, 0x1b, 0xd0, 0x7b, 0xc6, 0x63, 0x41, 0x63, 0x91, 0x8b, 0x77,
-	0xf2, 0x06, 0x7c, 0x00, 0x37, 0xfc, 0x31, 0x1f, 0x9d, 0xe9, 0x68, 0x80, 0xf6, 0x3a, 0x0f, 0x76,
-	0xed, 0xf5, 0xbb, 0xec, 0x61, 0x21, 0x97, 0xb4, 0x5b, 0xb2, 0xf8, 0x09, 0xb4, 0xe8, 0x24, 0x0a,
-	0x68, 0x3c, 0xa2, 0xfa, 0x86, 0xf4, 0x0d, 0xae, 0xfa, 0x5e, 0x54, 0x44, 0x65, 0xfd, 0xef, 0xc0,
-	0x87, 0xd0, 0x9e, 0x90, 0x71, 0x14, 0x90, 0x8c, 0xa7, 0xba, 0x26, 0xed, 0xf7, 0xae, 0xda, 0x3f,
-	0x2a, 0xa4, 0xf2, 0xd7, 0x1e, 0xfc, 0x08, 0xb6, 0x26, 0x34, 0x15, 0x11, 0x8f, 0xf5, 0xa6, 0xb4,
-	0x9b, 0xd7, 0xd8, 0x4b, 0xa0, 0x32, 0x2b, 0xde, 0x7a, 0x05, 0x9d, 0xa5, 0x3c, 0xf8, 0x2e, 0xb4,
-	0x19, 0x99, 0x7a, 0xfe, 0x2c, 0xa3, 0x42, 0x36, 0xa0, 0xb9, 0x2d, 0x46, 0xa6, 0xc3, 0xe2, 0x1b,
-	0xdf, 0x86, 0xad, 0x42, 0x0c, 0x89, 0x90, 0x21, 0x35, 0x77, 0x93, 0x91, 0xe9, 0x11, 0x11, 0xaf,
-	0x9b, 0x2d, 0xad, 0xdf, 0xb4, 0xbe, 0x23, 0xd8, 0x5e, 0xcd, 0x88, 0xf7, 0x01, 0x17, 0x0e, 0x12,
-	0x52, 0x2f, 0xce, 0x99, 0x27, 0xcb, 0x52, 0xe7, 0xf6, 0x18, 0x99, 0x3e, 0x0d, 0xe9, 0xdb, 0x9c,
-	0xc9, 0x1f, 0x10, 0xf8, 0x18, 0xfa, 0x0a, 0x56, 0xef, 0x54, 0x95, 0x79, 0xc7, 0x2e, 0x1f, 0xd2,
-	0x56, 0x0f, 0x69, 0x3f, 0xaf, 0x80, 0x61, 0xeb, 0xe2, 0x97, 0xd9, 0xf8, 0xfa, 0xdb, 0x44, 0xee,
-	0x76, 0x79, 0x9e, 0x52, 0x56, 0xa3, 0x68, 0xab, 0x51, 0xac, 0x43, 0xe8, 0xad, 0xf5, 0x89, 0x2d,
-	0xe8, 0x26, 0xb9, 0xef, 0x9d, 0xd1, 0x99, 0x27, 0x1b, 0xd3, 0xd1, 0x40, 0xdb, 0x6b, 0xbb, 0x9d,
-	0x24, 0xf7, 0xdf, 0xd0, 0xd9, 0xfb, 0x62, 0xeb, 0x71, 0xeb, 0xc7, 0xb9, 0x89, 0xfe, 0x9e, 0x9b,
-	0xc8, 0xda, 0x87, 0xee, 0x4a, 0xa3, 0xb8, 0x0f, 0x1a, 0x49, 0x12, 0x99, 0xad, 0xe9, 0x16, 0xcb,
-	0x25, 0xf8, 0x04, 0x6e, 0xbe, 0x24, 0xe2, 0x94, 0x06, 0x15, 0x7b, 0x1f, 0x7a, 0xb2, 0x0a, 0x6f,
-	0xbd, 0xeb, 0xae, 0xdc, 0x3e, 0x56, 0x85, 0x5b, 0xd0, 0xad, 0xb9, 0xba, 0xf6, 0x8e, 0xa2, 0x8e,
-	0x88, 0x18, 0x7e, 0xf8, 0x36, 0x37, 0xd0, 0xc5, 0xdc, 0x40, 0x97, 0x73, 0x03, 0xfd, 0x99, 0x1b,
-	0xe8, 0xcb, 0xc2, 0x68, 0x5c, 0x2e, 0x8c, 0xc6, 0xcf, 0x85, 0xd1, 0x38, 0x79, 0x18, 0x46, 0xd9,
-	0x69, 0xee, 0xdb, 0x23, 0xce, 0x9c, 0xe5, 0x99, 0xaa, 0x97, 0xe5, 0xd0, 0xac, 0xcf, 0x9b, 0xbf,
-	0x29, 0xf7, 0x0f, 0xfe, 0x05, 0x00, 0x00, 0xff, 0xff, 0x48, 0xd2, 0x61, 0x14, 0x8a, 0x03, 0x00,
-	0x00,
+	// 573 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x93, 0x3f, 0x6f, 0xd3, 0x4e,
+	0x18, 0xc7, 0x73, 0x75, 0xda, 0xa6, 0x4f, 0x7e, 0x69, 0xa2, 0xd3, 0x4f, 0xc2, 0x14, 0xe2, 0x04,
+	0x0f, 0xa8, 0x52, 0x25, 0x1b, 0xd1, 0x01, 0x81, 0x90, 0xaa, 0xa4, 0x44, 0x6d, 0x41, 0x05, 0x64,
+	0x01, 0x43, 0x17, 0xeb, 0x9c, 0x1c, 0x8e, 0xd5, 0xd8, 0x67, 0xf9, 0xce, 0x51, 0xf2, 0x2e, 0x18,
+	0x19, 0x3b, 0xc2, 0xca, 0xc4, 0x4b, 0xe8, 0xd8, 0x91, 0x09, 0x50, 0xb2, 0xf0, 0x32, 0x90, 0xcf,
+	0x76, 0x9d, 0x3f, 0x6c, 0x77, 0xf7, 0x7c, 0x3e, 0xf7, 0xe7, 0xfb, 0xe8, 0xa0, 0x29, 0x68, 0x30,
+	0xa0, 0x91, 0xef, 0x05, 0xc2, 0x14, 0xd3, 0x90, 0x72, 0x33, 0x24, 0x11, 0xf1, 0xb9, 0x11, 0x46,
+	0x4c, 0x30, 0xdc, 0x28, 0xca, 0x86, 0x2c, 0xef, 0xfd, 0xef, 0x32, 0x97, 0xc9, 0xa2, 0x99, 0x8c,
+	0x52, 0x6e, 0x4f, 0x73, 0x19, 0x73, 0x47, 0xd4, 0x94, 0x33, 0x27, 0xfe, 0x68, 0x0e, 0xe2, 0x88,
+	0x08, 0x8f, 0x05, 0x69, 0x5d, 0xff, 0xb6, 0x01, 0xf5, 0x63, 0x16, 0x70, 0x1a, 0xf0, 0x98, 0xbf,
+	0x95, 0x27, 0xe0, 0x43, 0xd8, 0x74, 0x46, 0xac, 0x7f, 0xa9, 0xa2, 0x36, 0xda, 0xaf, 0x3e, 0x6e,
+	0x1a, 0xab, 0x67, 0x19, 0xdd, 0xa4, 0x9c, 0xd2, 0x56, 0xca, 0xe2, 0xe7, 0x50, 0xa1, 0x63, 0x6f,
+	0x40, 0x83, 0x3e, 0x55, 0x37, 0xa4, 0xd7, 0x5e, 0xf7, 0x7a, 0x19, 0x91, 0xa9, 0xb7, 0x06, 0x3e,
+	0x82, 0x9d, 0x31, 0x19, 0x79, 0x03, 0x22, 0x58, 0xa4, 0x2a, 0x52, 0x7f, 0xb0, 0xae, 0x7f, 0xc8,
+	0x91, 0xcc, 0x2f, 0x1c, 0xfc, 0x14, 0xb6, 0xc7, 0x34, 0xe2, 0x1e, 0x0b, 0xd4, 0xb2, 0xd4, 0x5b,
+	0xff, 0xd0, 0x53, 0x20, 0x93, 0x73, 0x1e, 0x3f, 0x82, 0x32, 0x71, 0xfa, 0x9e, 0xba, 0x29, 0xbd,
+	0xfb, 0xeb, 0x5e, 0xa7, 0x7b, 0x7c, 0x96, 0x49, 0x92, 0xd4, 0xcf, 0xa0, 0xba, 0x90, 0x00, 0xbe,
+	0x07, 0x3b, 0x3e, 0x99, 0xd8, 0xce, 0x54, 0x50, 0x2e, 0x33, 0x53, 0xac, 0x8a, 0x4f, 0x26, 0xdd,
+	0x64, 0x8e, 0xef, 0xc0, 0x76, 0x52, 0x74, 0x09, 0x97, 0xb1, 0x28, 0xd6, 0x96, 0x4f, 0x26, 0x27,
+	0x84, 0xbf, 0x2c, 0x57, 0x94, 0x46, 0x59, 0xff, 0x8a, 0x60, 0x77, 0x39, 0x15, 0x7c, 0x00, 0x38,
+	0x31, 0x88, 0x4b, 0xed, 0x20, 0xf6, 0x6d, 0x19, 0x6f, 0xbe, 0x6f, 0xdd, 0x27, 0x93, 0x8e, 0x4b,
+	0x5f, 0xc7, 0xbe, 0xbc, 0x00, 0xc7, 0xe7, 0xd0, 0xc8, 0xe1, 0xbc, 0xb3, 0x59, 0xfc, 0x77, 0x8d,
+	0xb4, 0xf5, 0x46, 0xde, 0x7a, 0xe3, 0x45, 0x06, 0x74, 0x2b, 0xd7, 0x3f, 0x5b, 0xa5, 0xcf, 0xbf,
+	0x5a, 0xc8, 0xda, 0x4d, 0xf7, 0xcb, 0x2b, 0xcb, 0x4f, 0x51, 0x96, 0x9f, 0xa2, 0x1f, 0x41, 0x7d,
+	0xa5, 0x03, 0x58, 0x87, 0x5a, 0x18, 0x3b, 0xf6, 0x25, 0x9d, 0xda, 0x32, 0x2b, 0x15, 0xb5, 0x95,
+	0xfd, 0x1d, 0xab, 0x1a, 0xc6, 0xce, 0x2b, 0x3a, 0x7d, 0x97, 0x2c, 0x3d, 0xab, 0x7c, 0xbf, 0x6a,
+	0xa1, 0x3f, 0x57, 0x2d, 0xa4, 0x1f, 0x40, 0x6d, 0xa9, 0x07, 0xb8, 0x01, 0x0a, 0x09, 0x43, 0xf9,
+	0xb6, 0xb2, 0x95, 0x0c, 0x17, 0xe0, 0x0b, 0xf8, 0xef, 0x94, 0xf0, 0x21, 0x1d, 0x64, 0xec, 0x43,
+	0xa8, 0xcb, 0x28, 0xec, 0xd5, 0xac, 0x6b, 0x72, 0xf9, 0x3c, 0x0f, 0x5c, 0x87, 0x5a, 0xc1, 0x15,
+	0xb1, 0x57, 0x73, 0xea, 0x84, 0x70, 0xfd, 0x0d, 0x40, 0xd1, 0x54, 0xdc, 0x81, 0xe6, 0x98, 0x09,
+	0x6a, 0xd3, 0x89, 0xa0, 0x41, 0x72, 0x3b, 0x6e, 0xd3, 0x80, 0x38, 0x23, 0x6a, 0x0f, 0xa9, 0xe7,
+	0x0e, 0x45, 0x76, 0xce, 0x5e, 0x02, 0xf5, 0x6e, 0x99, 0x9e, 0x44, 0x4e, 0x25, 0xd1, 0x7d, 0xff,
+	0x65, 0xa6, 0xa1, 0xeb, 0x99, 0x86, 0x6e, 0x66, 0x1a, 0xfa, 0x3d, 0xd3, 0xd0, 0xa7, 0xb9, 0x56,
+	0xba, 0x99, 0x6b, 0xa5, 0x1f, 0x73, 0xad, 0x74, 0xf1, 0xc4, 0xf5, 0xc4, 0x30, 0x76, 0x8c, 0x3e,
+	0xf3, 0xcd, 0xc5, 0x6f, 0x5d, 0x0c, 0xd3, 0x7f, 0xbb, 0xfa, 0xe5, 0x9d, 0x2d, 0xb9, 0x7e, 0xf8,
+	0x37, 0x00, 0x00, 0xff, 0xff, 0x97, 0xf3, 0x81, 0x30, 0x0d, 0x04, 0x00, 0x00,
 }
 
 func (this *ConsensusParams) Equal(that interface{}) bool {
@@ -452,6 +518,9 @@ func (this *ConsensusParams) Equal(that interface{}) bool {
 	if !this.Version.Equal(that1.Version) {
 		return false
 	}
+	if !this.Abci.Equal(that1.Abci) {
+		return false
+	}
 	return true
 }
 func (this *BlockParams) Equal(that interface{}) bool {
@@ -591,6 +660,30 @@ func (this *HashedParams) Equal(that interface{}) bool {
 	}
 	return true
 }
+func (this *ABCIParams) Equal(that interface{}) bool {
+	if that == nil {
+		return this == nil
+	}
+
+	that1, ok := that.(*ABCIParams)
+	if !ok {
+		that2, ok := that.(ABCIParams)
+		if ok {
+			that1 = &that2
+		} else {
+			return false
+		}
+	}
+	if that1 == nil {
+		return this == nil
+	} else if this == nil {
+		return false
+	}
+	if this.VoteExtensionsEnableHeight != that1.VoteExtensionsEnableHeight {
+		return false
+	}
+	return true
+}
 func (m *ConsensusParams) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -611,6 +704,18 @@ func (m *ConsensusParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
+	if m.Abci != nil {
+		{
+			size, err := m.Abci.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintParams(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x2a
+	}
 	if m.Version != nil {
 		{
 			size, err := m.Version.MarshalToSizedBuffer(dAtA[:i])
@@ -720,12 +825,12 @@ 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):])
-	if err5 != nil {
-		return 0, err5
+	n6, err6 := github_com_cosmos_gogoproto_types.StdDurationMarshalTo(m.MaxAgeDuration, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.MaxAgeDuration):])
+	if err6 != nil {
+		return 0, err6
 	}
-	i -= n5
-	i = encodeVarintParams(dAtA, i, uint64(n5))
+	i -= n6
+	i = encodeVarintParams(dAtA, i, uint64(n6))
 	i--
 	dAtA[i] = 0x12
 	if m.MaxAgeNumBlocks != 0 {
@@ -829,6 +934,34 @@ func (m *HashedParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
+func (m *ABCIParams) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *ABCIParams) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ABCIParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.VoteExtensionsEnableHeight != 0 {
+		i = encodeVarintParams(dAtA, i, uint64(m.VoteExtensionsEnableHeight))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
 func encodeVarintParams(dAtA []byte, offset int, v uint64) int {
 	offset -= sovParams(v)
 	base := offset
@@ -954,6 +1087,10 @@ func (m *ConsensusParams) Size() (n int) {
 		l = m.Version.Size()
 		n += 1 + l + sovParams(uint64(l))
 	}
+	if m.Abci != nil {
+		l = m.Abci.Size()
+		n += 1 + l + sovParams(uint64(l))
+	}
 	return n
 }
 
@@ -1031,6 +1168,18 @@ func (m *HashedParams) Size() (n int) {
 	return n
 }
 
+func (m *ABCIParams) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.VoteExtensionsEnableHeight != 0 {
+		n += 1 + sovParams(uint64(m.VoteExtensionsEnableHeight))
+	}
+	return n
+}
+
 func sovParams(x uint64) (n int) {
 	return (math_bits.Len64(x|1) + 6) / 7
 }
@@ -1210,6 +1359,42 @@ func (m *ConsensusParams) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Abci", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowParams
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthParams
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthParams
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Abci == nil {
+				m.Abci = &ABCIParams{}
+			}
+			if err := m.Abci.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipParams(dAtA[iNdEx:])
@@ -1679,6 +1864,75 @@ func (m *HashedParams) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *ABCIParams) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowParams
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: ABCIParams: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ABCIParams: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field VoteExtensionsEnableHeight", wireType)
+			}
+			m.VoteExtensionsEnableHeight = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowParams
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.VoteExtensionsEnableHeight |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipParams(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthParams
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func skipParams(dAtA []byte) (n int, err error) {
 	l := len(dAtA)
 	iNdEx := 0
diff --git a/proto/tendermint/types/params.proto b/proto/tendermint/types/params.proto
index 195aa8d17..7af2280d7 100644
--- a/proto/tendermint/types/params.proto
+++ b/proto/tendermint/types/params.proto
@@ -15,6 +15,7 @@ message ConsensusParams {
   EvidenceParams  evidence  = 2;
   ValidatorParams validator = 3;
   VersionParams   version   = 4;
+  ABCIParams      abci      = 5;
 }
 
 // BlockParams contains limits on the block size.
@@ -75,3 +76,17 @@ message HashedParams {
   int64 block_max_bytes = 1;
   int64 block_max_gas   = 2;
 }
+
+// ABCIParams configure functionality specific to the Application Blockchain Interface.
+message ABCIParams {
+  // vote_extensions_enable_height configures the first height during which
+  // vote extensions will be enabled. During this specified height, and for all
+  // subsequent heights, precommit messages that do not contain valid extension data
+  // will be considered invalid. Prior to this height, vote extensions will not
+  // be used or accepted by validators on the network.
+  //
+  // Once enabled, vote extensions will be created by the application in ExtendVote,
+  // passed to the application for validation in VerifyVoteExtension and given
+  // to the application to use when proposing a block during PrepareProposal.
+  int64 vote_extensions_enable_height = 1;
+}
diff --git a/state/execution.go b/state/execution.go
index 7a27694f9..4d3310724 100644
--- a/state/execution.go
+++ b/state/execution.go
@@ -532,7 +532,7 @@ func updateState(
 	if len(validatorUpdates) > 0 {
 		err := nValSet.UpdateWithChangeSet(validatorUpdates)
 		if err != nil {
-			return state, fmt.Errorf("error changing validator set: %v", err)
+			return state, fmt.Errorf("changing validator set: %w", err)
 		}
 		// Change results from this height but only applies to the next next height.
 		lastHeightValsChanged = header.Height + 1 + 1
@@ -545,11 +545,16 @@ func updateState(
 	nextParams := state.ConsensusParams
 	lastHeightParamsChanged := state.LastHeightConsensusParamsChanged
 	if abciResponse.ConsensusParamUpdates != nil {
-		// NOTE: must not mutate s.ConsensusParams
+		// NOTE: must not mutate state.ConsensusParams
 		nextParams = state.ConsensusParams.Update(abciResponse.ConsensusParamUpdates)
 		err := nextParams.ValidateBasic()
 		if err != nil {
-			return state, fmt.Errorf("error updating consensus params: %v", err)
+			return state, fmt.Errorf("updating consensus params: %w", err)
+		}
+
+		err = state.ConsensusParams.ValidateUpdate(abciResponse.ConsensusParamUpdates, header.Height)
+		if err != nil {
+			return state, fmt.Errorf("updating consensus params: %w", err)
 		}
 
 		state.Version.Consensus.App = nextParams.Version.App
diff --git a/state/store.go b/state/store.go
index 002fbd1ce..f74fc9895 100644
--- a/state/store.go
+++ b/state/store.go
@@ -1,12 +1,10 @@
 package state
 
 import (
-	"encoding/binary"
 	"errors"
 	"fmt"
 
 	"github.com/cosmos/gogoproto/proto"
-	"github.com/google/orderedcode"
 	dbm "github.com/tendermint/tm-db"
 
 	abci "github.com/tendermint/tendermint/abci/types"
@@ -39,18 +37,6 @@ func calcABCIResponsesKey(height int64) []byte {
 	return []byte(fmt.Sprintf("abciResponsesKey:%v", height))
 }
 
-var tmpABCIKey []byte
-
-func init() {
-	var err error
-	// temporary extra key before consensus param protos are regenerated
-	// TODO(wbanfield) remove in next PR
-	tmpABCIKey, err = orderedcode.Append(nil, int64(10000))
-	if err != nil {
-		panic(err)
-	}
-}
-
 //----------------------
 
 var lastABCIResponseKey = []byte("lastABCIResponseKey")
@@ -176,13 +162,6 @@ func (store dbStore) loadState(key []byte) (state State, err error) {
 	if err != nil {
 		return state, err
 	}
-	buf, err = store.db.Get(tmpABCIKey)
-	if err != nil {
-		return state, err
-	}
-	h, _ := binary.Varint(buf)
-	sm.ConsensusParams.ABCI.VoteExtensionsEnableHeight = h
-
 	return *sm, nil
 }
 
@@ -217,11 +196,6 @@ func (store dbStore) save(state State, key []byte) error {
 	if err != nil {
 		return err
 	}
-	bz := make([]byte, 5)
-	binary.PutVarint(bz, state.ConsensusParams.ABCI.VoteExtensionsEnableHeight)
-	if err := store.db.SetSync(tmpABCIKey, bz); err != nil {
-		return err
-	}
 
 	return nil
 }
diff --git a/test/e2e/generator/generate.go b/test/e2e/generator/generate.go
index a0c65305f..048274b1b 100644
--- a/test/e2e/generator/generate.go
+++ b/test/e2e/generator/generate.go
@@ -47,6 +47,8 @@ var (
 		"kill":       0.1,
 		"restart":    0.1,
 	}
+	voteExtensionEnableHeightOffset = uniformChoice{int64(0), int64(10), int64(100)}
+	voteExtensionEnabled            = uniformChoice{true, false}
 )
 
 // Generate generates random testnets using the given RNG.
@@ -86,6 +88,10 @@ func generateTestnet(r *rand.Rand, opt map[string]interface{}) (e2e.Manifest, er
 		manifest.CheckTxDelay = 20 * time.Millisecond
 	}
 
+	if voteExtensionEnabled.Choose(r).(bool) {
+		manifest.VoteExtensionsEnableHeight = manifest.InitialHeight + voteExtensionEnableHeightOffset.Choose(r).(int64)
+	}
+
 	var numSeeds, numValidators, numFulls, numLightClients int
 	switch opt["topology"].(string) {
 	case "single":
diff --git a/test/e2e/pkg/manifest.go b/test/e2e/pkg/manifest.go
index 5d834e24a..a7f6c86a8 100644
--- a/test/e2e/pkg/manifest.go
+++ b/test/e2e/pkg/manifest.go
@@ -56,6 +56,11 @@ type Manifest struct {
 	// testnet via the RPC endpoint of a random node. Default is 0
 	Evidence int `toml:"evidence"`
 
+	// VoteExtensionsEnableHeight configures the first height during which
+	// the chain will use and require vote extension data to be present
+	// in precommit messages.
+	VoteExtensionsEnableHeight int64 `toml:"vote_extensions_enable_height"`
+
 	// ABCIProtocol specifies the protocol used to communicate with the ABCI
 	// application: "unix", "tcp", "grpc", or "builtin". Defaults to builtin.
 	// builtin will build a complete Tendermint node into the application and
diff --git a/test/e2e/pkg/testnet.go b/test/e2e/pkg/testnet.go
index 534e4ca4d..cffa4b216 100644
--- a/test/e2e/pkg/testnet.go
+++ b/test/e2e/pkg/testnet.go
@@ -56,24 +56,25 @@ const (
 
 // Testnet represents a single testnet.
 type Testnet struct {
-	Name                 string
-	File                 string
-	Dir                  string
-	IP                   *net.IPNet
-	InitialHeight        int64
-	InitialState         map[string]string
-	Validators           map[*Node]int64
-	ValidatorUpdates     map[int64]map[*Node]int64
-	Nodes                []*Node
-	KeyType              string
-	Evidence             int
-	LoadTxSizeBytes      int
-	LoadTxBatchSize      int
-	LoadTxConnections    int
-	ABCIProtocol         string
-	PrepareProposalDelay time.Duration
-	ProcessProposalDelay time.Duration
-	CheckTxDelay         time.Duration
+	Name                       string
+	File                       string
+	Dir                        string
+	IP                         *net.IPNet
+	InitialHeight              int64
+	InitialState               map[string]string
+	Validators                 map[*Node]int64
+	ValidatorUpdates           map[int64]map[*Node]int64
+	Nodes                      []*Node
+	KeyType                    string
+	Evidence                   int
+	LoadTxSizeBytes            int
+	LoadTxBatchSize            int
+	LoadTxConnections          int
+	ABCIProtocol               string
+	PrepareProposalDelay       time.Duration
+	ProcessProposalDelay       time.Duration
+	CheckTxDelay               time.Duration
+	VoteExtensionsEnableHeight int64
 }
 
 // Node represents a Tendermint node in a testnet.
diff --git a/test/e2e/runner/evidence.go b/test/e2e/runner/evidence.go
index d21c2f8f4..a988bf709 100644
--- a/test/e2e/runner/evidence.go
+++ b/test/e2e/runner/evidence.go
@@ -94,9 +94,15 @@ func InjectEvidence(ctx context.Context, r *rand.Rand, testnet *e2e.Testnet, amo
 				ctx, privVals, evidenceHeight, valSet, testnet.Name, blockRes.Block.Time,
 			)
 		} else {
-			ev, err = generateDuplicateVoteEvidence(
+			var dve *types.DuplicateVoteEvidence
+			dve, err = generateDuplicateVoteEvidence(
 				ctx, privVals, evidenceHeight, valSet, testnet.Name, blockRes.Block.Time,
 			)
+			if dve.VoteA.Height < testnet.VoteExtensionsEnableHeight {
+				dve.VoteA.StripExtension()
+				dve.VoteB.StripExtension()
+			}
+			ev = dve
 		}
 		if err != nil {
 			return err
diff --git a/test/e2e/runner/setup.go b/test/e2e/runner/setup.go
index c398bbe95..7de446c9f 100644
--- a/test/e2e/runner/setup.go
+++ b/test/e2e/runner/setup.go
@@ -131,6 +131,9 @@ func MakeGenesis(testnet *e2e.Testnet) (types.GenesisDoc, error) {
 	}
 	// set the app version to 1
 	genesis.ConsensusParams.Version.App = 1
+	genesis.ConsensusParams.Evidence.MaxAgeNumBlocks = e2e.EvidenceAgeHeight
+	genesis.ConsensusParams.Evidence.MaxAgeDuration = e2e.EvidenceAgeTime
+	genesis.ConsensusParams.ABCI.VoteExtensionsEnableHeight = testnet.VoteExtensionsEnableHeight
 	for validator, power := range testnet.Validators {
 		genesis.Validators = append(genesis.Validators, types.GenesisValidator{
 			Name:    validator.Name,
diff --git a/test/e2e/tests/app_test.go b/test/e2e/tests/app_test.go
index 34ab5e14f..c79de358e 100644
--- a/test/e2e/tests/app_test.go
+++ b/test/e2e/tests/app_test.go
@@ -2,6 +2,7 @@ package e2e_test
 
 import (
 	"bytes"
+	"errors"
 	"fmt"
 	"math/rand"
 	"strconv"
@@ -107,16 +108,25 @@ func TestApp_Tx(t *testing.T) {
 
 func TestApp_VoteExtensions(t *testing.T) {
 	testNode(t, func(t *testing.T, node e2e.Node) {
-		t.Skip()
 		client, err := node.Client()
 		require.NoError(t, err)
+		info, err := client.ABCIInfo(ctx)
+		require.NoError(t, err)
 
 		// This special value should have been created by way of vote extensions
 		resp, err := client.ABCIQuery(ctx, "", []byte("extensionSum"))
 		require.NoError(t, err)
 
 		extSum, err := strconv.Atoi(string(resp.Response.Value))
-		require.NoError(t, err)
-		require.GreaterOrEqual(t, extSum, 0)
+		// if extensions are not enabled on the network, we should not expect
+		// the app to have any extension value set.
+		if node.Testnet.VoteExtensionsEnableHeight == 0 ||
+			info.Response.LastBlockHeight < node.Testnet.VoteExtensionsEnableHeight+1 {
+			target := &strconv.NumError{}
+			require.True(t, errors.As(err, &target))
+		} else {
+			require.NoError(t, err)
+			require.GreaterOrEqual(t, extSum, 0)
+		}
 	})
 }
diff --git a/types/params.go b/types/params.go
index 7dd032060..3a95ec383 100644
--- a/types/params.go
+++ b/types/params.go
@@ -174,6 +174,10 @@ func (params ConsensusParams) ValidateBasic() error {
 			params.Evidence.MaxBytes)
 	}
 
+	if params.ABCI.VoteExtensionsEnableHeight < 0 {
+		return fmt.Errorf("ABCI.VoteExtensionsEnableHeight cannot be negative. Got: %d", params.ABCI.VoteExtensionsEnableHeight)
+	}
+
 	if len(params.Validator.PubKeyTypes) == 0 {
 		return errors.New("len(Validator.PubKeyTypes) must be greater than 0")
 	}
@@ -190,6 +194,30 @@ func (params ConsensusParams) ValidateBasic() error {
 	return nil
 }
 
+func (params ConsensusParams) ValidateUpdate(updated *tmproto.ConsensusParams, h int64) error {
+	if updated.Abci == nil {
+		return nil
+	}
+	if params.ABCI.VoteExtensionsEnableHeight == updated.Abci.VoteExtensionsEnableHeight {
+		return nil
+	}
+	if params.ABCI.VoteExtensionsEnableHeight != 0 && updated.Abci.VoteExtensionsEnableHeight == 0 {
+		return errors.New("vote extensions cannot be disabled once enabled")
+	}
+	if updated.Abci.VoteExtensionsEnableHeight <= h {
+		return fmt.Errorf("VoteExtensionsEnableHeight cannot be updated to a past height, "+
+			"initial height: %d, current height %d",
+			params.ABCI.VoteExtensionsEnableHeight, h)
+	}
+	if params.ABCI.VoteExtensionsEnableHeight <= h {
+		return fmt.Errorf("VoteExtensionsEnableHeight cannot be modified once"+
+			"the initial height has occurred, "+
+			"initial height: %d, current height %d",
+			params.ABCI.VoteExtensionsEnableHeight, h)
+	}
+	return nil
+}
+
 // Hash returns a hash of a subset of the parameters to store in the block header.
 // Only the Block.MaxBytes and Block.MaxGas are included in the hash.
 // This allows the ConsensusParams to evolve more without breaking the block
@@ -241,6 +269,9 @@ func (params ConsensusParams) Update(params2 *tmproto.ConsensusParams) Consensus
 	if params2.Version != nil {
 		res.Version.App = params2.Version.App
 	}
+	if params2.Abci != nil {
+		res.ABCI.VoteExtensionsEnableHeight = params2.Abci.GetVoteExtensionsEnableHeight()
+	}
 	return res
 }
 
@@ -261,11 +292,14 @@ func (params *ConsensusParams) ToProto() tmproto.ConsensusParams {
 		Version: &tmproto.VersionParams{
 			App: params.Version.App,
 		},
+		Abci: &tmproto.ABCIParams{
+			VoteExtensionsEnableHeight: params.ABCI.VoteExtensionsEnableHeight,
+		},
 	}
 }
 
 func ConsensusParamsFromProto(pbParams tmproto.ConsensusParams) ConsensusParams {
-	return ConsensusParams{
+	c := ConsensusParams{
 		Block: BlockParams{
 			MaxBytes: pbParams.Block.MaxBytes,
 			MaxGas:   pbParams.Block.MaxGas,
@@ -282,4 +316,8 @@ func ConsensusParamsFromProto(pbParams tmproto.ConsensusParams) ConsensusParams
 			App: pbParams.Version.App,
 		},
 	}
+	if pbParams.Abci != nil {
+		c.ABCI.VoteExtensionsEnableHeight = pbParams.Abci.GetVoteExtensionsEnableHeight()
+	}
+	return c
 }
diff --git a/types/params_test.go b/types/params_test.go
index c3ef682b4..c07c56cc3 100644
--- a/types/params_test.go
+++ b/types/params_test.go
@@ -7,6 +7,7 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
 )
@@ -22,22 +23,22 @@ func TestConsensusParamsValidation(t *testing.T) {
 		valid  bool
 	}{
 		// test block params
-		0: {makeParams(1, 0, 2, 0, valEd25519), true},
-		1: {makeParams(0, 0, 2, 0, valEd25519), false},
-		2: {makeParams(47*1024*1024, 0, 2, 0, valEd25519), true},
-		3: {makeParams(10, 0, 2, 0, valEd25519), true},
-		4: {makeParams(100*1024*1024, 0, 2, 0, valEd25519), true},
-		5: {makeParams(101*1024*1024, 0, 2, 0, valEd25519), false},
-		6: {makeParams(1024*1024*1024, 0, 2, 0, valEd25519), false},
+		0: {makeParams(1, 0, 2, 0, valEd25519, 0), true},
+		1: {makeParams(0, 0, 2, 0, valEd25519, 0), false},
+		2: {makeParams(47*1024*1024, 0, 2, 0, valEd25519, 0), true},
+		3: {makeParams(10, 0, 2, 0, valEd25519, 0), true},
+		4: {makeParams(100*1024*1024, 0, 2, 0, valEd25519, 0), true},
+		5: {makeParams(101*1024*1024, 0, 2, 0, valEd25519, 0), false},
+		6: {makeParams(1024*1024*1024, 0, 2, 0, valEd25519, 0), false},
 		// test evidence params
-		7:  {makeParams(1, 0, 0, 0, valEd25519), false},
-		8:  {makeParams(1, 0, 2, 2, valEd25519), false},
-		9:  {makeParams(1000, 0, 2, 1, valEd25519), true},
-		10: {makeParams(1, 0, -1, 0, valEd25519), false},
+		7:  {makeParams(1, 0, 0, 0, valEd25519, 0), false},
+		8:  {makeParams(1, 0, 2, 2, valEd25519, 0), false},
+		9:  {makeParams(1000, 0, 2, 1, valEd25519, 0), true},
+		10: {makeParams(1, 0, -1, 0, valEd25519, 0), false},
 		// test no pubkey type provided
-		11: {makeParams(1, 0, 2, 0, []string{}), false},
+		11: {makeParams(1, 0, 2, 0, []string{}, 0), false},
 		// test invalid pubkey type provided
-		12: {makeParams(1, 0, 2, 0, []string{"potatoes make good pubkeys"}), false},
+		12: {makeParams(1, 0, 2, 0, []string{"potatoes make good pubkeys"}, 0), false},
 	}
 	for i, tc := range testCases {
 		if tc.valid {
@@ -53,6 +54,7 @@ func makeParams(
 	evidenceAge int64,
 	maxEvidenceBytes int64,
 	pubkeyTypes []string,
+	abciExtensionHeight int64,
 ) ConsensusParams {
 	return ConsensusParams{
 		Block: BlockParams{
@@ -67,19 +69,22 @@ func makeParams(
 		Validator: ValidatorParams{
 			PubKeyTypes: pubkeyTypes,
 		},
+		ABCI: ABCIParams{
+			VoteExtensionsEnableHeight: abciExtensionHeight,
+		},
 	}
 }
 
 func TestConsensusParamsHash(t *testing.T) {
 	params := []ConsensusParams{
-		makeParams(4, 2, 3, 1, valEd25519),
-		makeParams(1, 4, 3, 1, valEd25519),
-		makeParams(1, 2, 4, 1, valEd25519),
-		makeParams(2, 5, 7, 1, valEd25519),
-		makeParams(1, 7, 6, 1, valEd25519),
-		makeParams(9, 5, 4, 1, valEd25519),
-		makeParams(7, 8, 9, 1, valEd25519),
-		makeParams(4, 6, 5, 1, valEd25519),
+		makeParams(4, 2, 3, 1, valEd25519, 0),
+		makeParams(1, 4, 3, 1, valEd25519, 0),
+		makeParams(1, 2, 4, 1, valEd25519, 0),
+		makeParams(2, 5, 7, 1, valEd25519, 0),
+		makeParams(1, 7, 6, 1, valEd25519, 0),
+		makeParams(9, 5, 4, 1, valEd25519, 0),
+		makeParams(7, 8, 9, 1, valEd25519, 0),
+		makeParams(4, 6, 5, 1, valEd25519, 0),
 	}
 
 	hashes := make([][]byte, len(params))
@@ -105,13 +110,13 @@ func TestConsensusParamsUpdate(t *testing.T) {
 	}{
 		// empty updates
 		{
-			makeParams(1, 2, 3, 0, valEd25519),
+			makeParams(1, 2, 3, 0, valEd25519, 0),
 			&tmproto.ConsensusParams{},
-			makeParams(1, 2, 3, 0, valEd25519),
+			makeParams(1, 2, 3, 0, valEd25519, 0),
 		},
 		// fine updates
 		{
-			makeParams(1, 2, 3, 0, valEd25519),
+			makeParams(1, 2, 3, 0, valEd25519, 0),
 			&tmproto.ConsensusParams{
 				Block: &tmproto.BlockParams{
 					MaxBytes: 100,
@@ -126,7 +131,7 @@ func TestConsensusParamsUpdate(t *testing.T) {
 					PubKeyTypes: valSecp256k1,
 				},
 			},
-			makeParams(100, 200, 300, 50, valSecp256k1),
+			makeParams(100, 200, 300, 50, valSecp256k1, 0),
 		},
 	}
 
@@ -136,7 +141,7 @@ func TestConsensusParamsUpdate(t *testing.T) {
 }
 
 func TestConsensusParamsUpdate_AppVersion(t *testing.T) {
-	params := makeParams(1, 2, 3, 0, valEd25519)
+	params := makeParams(1, 2, 3, 0, valEd25519, 0)
 
 	assert.EqualValues(t, 0, params.Version.App)
 
@@ -146,16 +151,76 @@ func TestConsensusParamsUpdate_AppVersion(t *testing.T) {
 	assert.EqualValues(t, 1, updated.Version.App)
 }
 
+func TestConsensusParamsUpdate_VoteExtensionsEnableHeight(t *testing.T) {
+	t.Run("set to height but initial height already run", func(*testing.T) {
+		initialParams := makeParams(1, 0, 2, 0, valEd25519, 1)
+		update := &tmproto.ConsensusParams{
+			Abci: &tmproto.ABCIParams{
+				VoteExtensionsEnableHeight: 10,
+			},
+		}
+		require.Error(t, initialParams.ValidateUpdate(update, 1))
+		require.Error(t, initialParams.ValidateUpdate(update, 5))
+	})
+	t.Run("reset to 0", func(t *testing.T) {
+		initialParams := makeParams(1, 0, 2, 0, valEd25519, 1)
+		update := &tmproto.ConsensusParams{
+			Abci: &tmproto.ABCIParams{
+				VoteExtensionsEnableHeight: 0,
+			},
+		}
+		require.Error(t, initialParams.ValidateUpdate(update, 1))
+	})
+	t.Run("set to height before current height run", func(*testing.T) {
+		initialParams := makeParams(1, 0, 2, 0, valEd25519, 100)
+		update := &tmproto.ConsensusParams{
+			Abci: &tmproto.ABCIParams{
+				VoteExtensionsEnableHeight: 10,
+			},
+		}
+		require.Error(t, initialParams.ValidateUpdate(update, 11))
+		require.Error(t, initialParams.ValidateUpdate(update, 99))
+	})
+	t.Run("set to height after current height run", func(*testing.T) {
+		initialParams := makeParams(1, 0, 2, 0, valEd25519, 300)
+		update := &tmproto.ConsensusParams{
+			Abci: &tmproto.ABCIParams{
+				VoteExtensionsEnableHeight: 99,
+			},
+		}
+		require.NoError(t, initialParams.ValidateUpdate(update, 11))
+		require.NoError(t, initialParams.ValidateUpdate(update, 98))
+	})
+	t.Run("no error when unchanged", func(*testing.T) {
+		initialParams := makeParams(1, 0, 2, 0, valEd25519, 100)
+		update := &tmproto.ConsensusParams{
+			Abci: &tmproto.ABCIParams{
+				VoteExtensionsEnableHeight: 100,
+			},
+		}
+		require.NoError(t, initialParams.ValidateUpdate(update, 500))
+	})
+	t.Run("updated from 0 to 0", func(t *testing.T) {
+		initialParams := makeParams(1, 0, 2, 0, valEd25519, 0)
+		update := &tmproto.ConsensusParams{
+			Abci: &tmproto.ABCIParams{
+				VoteExtensionsEnableHeight: 0,
+			},
+		}
+		require.NoError(t, initialParams.ValidateUpdate(update, 100))
+	})
+}
+
 func TestProto(t *testing.T) {
 	params := []ConsensusParams{
-		makeParams(4, 2, 3, 1, valEd25519),
-		makeParams(1, 4, 3, 1, valEd25519),
-		makeParams(1, 2, 4, 1, valEd25519),
-		makeParams(2, 5, 7, 1, valEd25519),
-		makeParams(1, 7, 6, 1, valEd25519),
-		makeParams(9, 5, 4, 1, valEd25519),
-		makeParams(7, 8, 9, 1, valEd25519),
-		makeParams(4, 6, 5, 1, valEd25519),
+		makeParams(4, 2, 3, 1, valEd25519, 1),
+		makeParams(1, 4, 3, 1, valEd25519, 1),
+		makeParams(1, 2, 4, 1, valEd25519, 1),
+		makeParams(2, 5, 7, 1, valEd25519, 1),
+		makeParams(1, 7, 6, 1, valEd25519, 1),
+		makeParams(9, 5, 4, 1, valEd25519, 1),
+		makeParams(7, 8, 9, 1, valEd25519, 1),
+		makeParams(4, 6, 5, 1, valEd25519, 1),
 	}
 
 	for i := range params {