diff --git a/relayer/chains/penumbra/core/component/auction/v1/auction.pb.go b/relayer/chains/penumbra/core/component/auction/v1/auction.pb.go
index 2991ab3e5..bfa1050e6 100644
--- a/relayer/chains/penumbra/core/component/auction/v1/auction.pb.go
+++ b/relayer/chains/penumbra/core/component/auction/v1/auction.pb.go
@@ -1239,6 +1239,58 @@ func (m *EventDutchAuctionEnded) GetReason() EventDutchAuctionEnded_Reason {
 	return EventDutchAuctionEnded_REASON_UNSPECIFIED
 }
 
+type EventDutchAuctionWithdrawn struct {
+	AuctionId *AuctionId         `protobuf:"bytes,1,opt,name=auction_id,json=auctionId,proto3" json:"auction_id,omitempty"`
+	State     *DutchAuctionState `protobuf:"bytes,2,opt,name=state,proto3" json:"state,omitempty"`
+}
+
+func (m *EventDutchAuctionWithdrawn) Reset()         { *m = EventDutchAuctionWithdrawn{} }
+func (m *EventDutchAuctionWithdrawn) String() string { return proto.CompactTextString(m) }
+func (*EventDutchAuctionWithdrawn) ProtoMessage()    {}
+func (*EventDutchAuctionWithdrawn) Descriptor() ([]byte, []int) {
+	return fileDescriptor_5bd5c1fb0f471c5d, []int{20}
+}
+func (m *EventDutchAuctionWithdrawn) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *EventDutchAuctionWithdrawn) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_EventDutchAuctionWithdrawn.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 *EventDutchAuctionWithdrawn) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_EventDutchAuctionWithdrawn.Merge(m, src)
+}
+func (m *EventDutchAuctionWithdrawn) XXX_Size() int {
+	return m.Size()
+}
+func (m *EventDutchAuctionWithdrawn) XXX_DiscardUnknown() {
+	xxx_messageInfo_EventDutchAuctionWithdrawn.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EventDutchAuctionWithdrawn proto.InternalMessageInfo
+
+func (m *EventDutchAuctionWithdrawn) GetAuctionId() *AuctionId {
+	if m != nil {
+		return m.AuctionId
+	}
+	return nil
+}
+
+func (m *EventDutchAuctionWithdrawn) GetState() *DutchAuctionState {
+	if m != nil {
+		return m.State
+	}
+	return nil
+}
+
 // A message emitted when value flows *into* the auction component.
 type EventValueCircuitBreakerCredit struct {
 	// The asset ID being deposited into the Auction component.
@@ -1253,7 +1305,7 @@ func (m *EventValueCircuitBreakerCredit) Reset()         { *m = EventValueCircui
 func (m *EventValueCircuitBreakerCredit) String() string { return proto.CompactTextString(m) }
 func (*EventValueCircuitBreakerCredit) ProtoMessage()    {}
 func (*EventValueCircuitBreakerCredit) Descriptor() ([]byte, []int) {
-	return fileDescriptor_5bd5c1fb0f471c5d, []int{20}
+	return fileDescriptor_5bd5c1fb0f471c5d, []int{21}
 }
 func (m *EventValueCircuitBreakerCredit) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1317,7 +1369,7 @@ func (m *EventValueCircuitBreakerDebit) Reset()         { *m = EventValueCircuit
 func (m *EventValueCircuitBreakerDebit) String() string { return proto.CompactTextString(m) }
 func (*EventValueCircuitBreakerDebit) ProtoMessage()    {}
 func (*EventValueCircuitBreakerDebit) Descriptor() ([]byte, []int) {
-	return fileDescriptor_5bd5c1fb0f471c5d, []int{21}
+	return fileDescriptor_5bd5c1fb0f471c5d, []int{22}
 }
 func (m *EventValueCircuitBreakerDebit) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1389,6 +1441,7 @@ func init() {
 	proto.RegisterType((*EventDutchAuctionScheduled)(nil), "penumbra.core.component.auction.v1.EventDutchAuctionScheduled")
 	proto.RegisterType((*EventDutchAuctionUpdated)(nil), "penumbra.core.component.auction.v1.EventDutchAuctionUpdated")
 	proto.RegisterType((*EventDutchAuctionEnded)(nil), "penumbra.core.component.auction.v1.EventDutchAuctionEnded")
+	proto.RegisterType((*EventDutchAuctionWithdrawn)(nil), "penumbra.core.component.auction.v1.EventDutchAuctionWithdrawn")
 	proto.RegisterType((*EventValueCircuitBreakerCredit)(nil), "penumbra.core.component.auction.v1.EventValueCircuitBreakerCredit")
 	proto.RegisterType((*EventValueCircuitBreakerDebit)(nil), "penumbra.core.component.auction.v1.EventValueCircuitBreakerDebit")
 }
@@ -1398,93 +1451,94 @@ func init() {
 }
 
 var fileDescriptor_5bd5c1fb0f471c5d = []byte{
-	// 1372 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x58, 0xcd, 0x6e, 0xdb, 0x46,
-	0x10, 0x36, 0xe9, 0x9f, 0xd8, 0x63, 0xc7, 0x56, 0x36, 0x69, 0xa2, 0x08, 0x8d, 0x9a, 0xf0, 0x10,
-	0xb8, 0x05, 0x4a, 0x45, 0x0e, 0x7a, 0x91, 0xe3, 0x02, 0xfa, 0xb3, 0x2b, 0xd4, 0xb1, 0x55, 0xba,
-	0x71, 0x7e, 0xe0, 0x80, 0xa0, 0xc9, 0x89, 0x45, 0xd4, 0x5c, 0x2a, 0xe4, 0x52, 0xb6, 0xd1, 0x67,
-	0x68, 0x51, 0xe4, 0x11, 0x7a, 0x6c, 0x8f, 0x45, 0x51, 0xa0, 0x4f, 0xd0, 0xf6, 0x94, 0x4b, 0x81,
-	0xa0, 0xa7, 0xc2, 0xee, 0xa9, 0xd7, 0x9c, 0x0b, 0x14, 0x24, 0x77, 0x29, 0x45, 0xb2, 0x62, 0xc5,
-	0x56, 0x80, 0xa2, 0x17, 0x61, 0x39, 0x9c, 0xef, 0x9b, 0x99, 0x6f, 0x67, 0x47, 0x24, 0xe1, 0x56,
-	0x13, 0x69, 0xe0, 0x6c, 0x7b, 0x46, 0xce, 0x74, 0x3d, 0xcc, 0x99, 0xae, 0xd3, 0x74, 0x29, 0x52,
-	0x96, 0x33, 0x02, 0x93, 0xd9, 0x2e, 0xcd, 0xb5, 0xf2, 0x62, 0xa9, 0x36, 0x3d, 0x97, 0xb9, 0x44,
-	0x11, 0x08, 0x35, 0x44, 0xa8, 0x09, 0x42, 0x15, 0x6e, 0xad, 0x7c, 0xe6, 0xea, 0x8e, 0xeb, 0xee,
-	0xec, 0x62, 0x2e, 0x42, 0x6c, 0x07, 0x4f, 0x72, 0x06, 0x3d, 0x88, 0xe1, 0x19, 0xe5, 0xd5, 0x80,
-	0x86, 0xef, 0x23, 0x8b, 0x82, 0x84, 0x0b, 0xee, 0x33, 0xdf, 0x2f, 0x29, 0x0b, 0xf7, 0x43, 0x5f,
-	0x0b, 0xf7, 0xb9, 0x67, 0xf6, 0x55, 0x4f, 0x1a, 0x38, 0xe1, 0x7d, 0x1a, 0x38, 0xf1, 0x7d, 0xe5,
-	0x22, 0x5c, 0x28, 0xc6, 0x69, 0xd5, 0x0d, 0xcf, 0x70, 0x90, 0xa1, 0xe7, 0x2b, 0x3a, 0xcc, 0xae,
-	0x20, 0x45, 0xdf, 0xf6, 0xcb, 0x2e, 0x65, 0x48, 0x19, 0xb9, 0x0b, 0x13, 0xcd, 0xf0, 0xbe, 0x9f,
-	0x96, 0xae, 0x4b, 0xf3, 0xd3, 0x0b, 0x1f, 0xa9, 0x27, 0x17, 0xa9, 0xf6, 0x10, 0x6b, 0x9c, 0x44,
-	0x79, 0x00, 0x57, 0xf8, 0xcd, 0x0d, 0x66, 0x30, 0x2c, 0x1d, 0xd4, 0x2c, 0x0d, 0x9f, 0x06, 0xe8,
-	0x33, 0xb2, 0x04, 0xb2, 0x6d, 0xf1, 0x28, 0x1f, 0xbe, 0x41, 0x94, 0x9a, 0xa5, 0xc9, 0xb6, 0xa5,
-	0x3c, 0x93, 0x20, 0xdd, 0x4b, 0xed, 0x37, 0x5d, 0xea, 0x23, 0x51, 0xe1, 0x1c, 0x07, 0xa6, 0xe5,
-	0x28, 0xc0, 0x25, 0x35, 0xde, 0x07, 0x55, 0xec, 0x83, 0x5a, 0xa4, 0x07, 0x9a, 0x70, 0x22, 0xcb,
-	0x30, 0xd5, 0x74, 0x7d, 0x3b, 0x5c, 0xfb, 0xe9, 0xd1, 0xeb, 0xa3, 0xf3, 0xd3, 0x0b, 0xf3, 0x7d,
-	0x53, 0x0a, 0x35, 0x6f, 0xe5, 0xd5, 0x3a, 0x07, 0x68, 0x6d, 0xa8, 0xf2, 0xb0, 0x37, 0x27, 0xbf,
-	0xbb, 0xde, 0xd1, 0xd3, 0xd5, 0xfb, 0x52, 0x82, 0xab, 0xc7, 0x70, 0xf3, 0x82, 0xcf, 0x26, 0x26,
-	0x59, 0xef, 0xd6, 0x6b, 0xa0, 0x6d, 0xaf, 0x04, 0xcc, 0x6c, 0x74, 0xe6, 0x34, 0x7c, 0x41, 0x6f,
-	0xc0, 0x54, 0x92, 0x29, 0xb9, 0x04, 0xe3, 0x36, 0xa5, 0xe8, 0x45, 0x75, 0xce, 0x68, 0xf1, 0x85,
-	0xf2, 0x18, 0x80, 0xbb, 0xac, 0x3d, 0x39, 0x6b, 0x57, 0x91, 0x14, 0x8c, 0xfa, 0xf8, 0x34, 0x12,
-	0x61, 0x4c, 0x0b, 0x97, 0xca, 0x3f, 0x32, 0x5c, 0xe9, 0x2c, 0xb4, 0x82, 0xbe, 0xe9, 0xd9, 0xcd,
-	0xa8, 0xca, 0xdb, 0x61, 0x42, 0xcd, 0x80, 0xf1, 0x78, 0xd7, 0xba, 0xe2, 0xc5, 0x07, 0xb9, 0x95,
-	0x57, 0x37, 0x8d, 0xdd, 0x00, 0xb5, 0xd8, 0x97, 0xdc, 0x81, 0x29, 0x37, 0x60, 0xcd, 0x80, 0xe9,
-	0xb6, 0xc5, 0xd5, 0x7e, 0xaf, 0x1f, 0xb0, 0x18, 0x2e, 0x6a, 0x96, 0x36, 0x19, 0x23, 0x6a, 0x16,
-	0x59, 0x04, 0x70, 0x8c, 0x7d, 0x3d, 0xbe, 0x4e, 0x8f, 0x46, 0xf0, 0x77, 0xbb, 0xe0, 0xe1, 0xa1,
-	0x0f, 0xc1, 0x8e, 0x1b, 0x50, 0xa6, 0x4d, 0x39, 0xc6, 0xfe, 0x7a, 0xe4, 0x1e, 0x81, 0x6d, 0x2a,
-	0xc0, 0x63, 0x03, 0x81, 0x6d, 0xca, 0xc1, 0x37, 0x60, 0xc6, 0x67, 0x86, 0xc7, 0xf4, 0x06, 0xda,
-	0x3b, 0x0d, 0x96, 0x1e, 0x8f, 0x34, 0x9a, 0x8e, 0x6c, 0x9f, 0x44, 0x26, 0x72, 0x0d, 0x00, 0xa9,
-	0x25, 0x1c, 0x26, 0x22, 0x87, 0x29, 0xa4, 0x56, 0xfb, 0xb6, 0xcf, 0xb0, 0xa9, 0x9b, 0x21, 0x75,
-	0xfa, 0x5c, 0x7c, 0x3b, 0xb4, 0x94, 0x43, 0x43, 0xb8, 0xbd, 0xd4, 0xa5, 0x26, 0xa6, 0x27, 0xe3,
-	0xed, 0x8d, 0x2e, 0x94, 0xef, 0x65, 0xb8, 0xd0, 0xd3, 0x68, 0x62, 0x9f, 0xa4, 0x64, 0x9f, 0xc8,
-	0x3d, 0x48, 0x99, 0x81, 0xe7, 0x21, 0x65, 0xba, 0x68, 0x1f, 0xae, 0xee, 0x07, 0x83, 0x36, 0x5e,
-	0xcd, 0xd2, 0xe6, 0x38, 0x87, 0x30, 0x85, 0x55, 0x53, 0xdc, 0x67, 0x3a, 0xf3, 0xec, 0x9d, 0x1d,
-	0xf4, 0x22, 0xc5, 0xc7, 0xb4, 0xe9, 0xd0, 0xf6, 0x79, 0x6c, 0x22, 0x65, 0x98, 0x8d, 0x76, 0x56,
-	0xf7, 0xd0, 0x47, 0xaf, 0x85, 0xfe, 0x40, 0xca, 0x9e, 0x8f, 0x30, 0x1a, 0x87, 0x90, 0x2a, 0xcc,
-	0xf1, 0xae, 0x48, 0x58, 0xc6, 0x07, 0x60, 0x99, 0x8d, 0x41, 0x82, 0x46, 0xf9, 0x59, 0x82, 0x99,
-	0x4e, 0xb5, 0xc8, 0x63, 0x98, 0xb6, 0xda, 0x1d, 0xcb, 0x1b, 0x75, 0xf1, 0x4d, 0x4f, 0x77, 0x47,
-	0xd3, 0x6b, 0x9d, 0x7c, 0xe4, 0x53, 0x18, 0xf7, 0xc3, 0x0d, 0x39, 0xdb, 0xd8, 0x88, 0x39, 0x94,
-	0x2f, 0x21, 0x53, 0x8c, 0xc3, 0x75, 0x7a, 0x98, 0x0d, 0xb4, 0x82, 0x5d, 0x7c, 0xcb, 0x95, 0x28,
-	0x08, 0xef, 0xf4, 0x06, 0xaf, 0x52, 0x8b, 0xac, 0x02, 0x70, 0x2e, 0xfd, 0xb4, 0x93, 0x65, 0xca,
-	0x10, 0x4b, 0xe5, 0x85, 0x74, 0x5c, 0x91, 0xf7, 0x6d, 0xd6, 0xb0, 0x3c, 0x63, 0x6f, 0xb8, 0xc1,
-	0x7a, 0xa7, 0x19, 0x79, 0x04, 0x17, 0x45, 0x7f, 0xe9, 0xa6, 0xeb, 0x38, 0x36, 0x73, 0x90, 0x8a,
-	0x39, 0xf2, 0x7e, 0xbf, 0x31, 0x54, 0x32, 0x76, 0x0d, 0x6a, 0x62, 0x39, 0x01, 0x68, 0x44, 0xb0,
-	0xb4, 0x6d, 0xca, 0xd7, 0x32, 0x64, 0xfb, 0x97, 0x56, 0xdf, 0x35, 0xe8, 0x5b, 0x2f, 0xaf, 0x02,
-	0xb3, 0x49, 0x79, 0xf1, 0x64, 0x1e, 0x1d, 0x64, 0x32, 0x9f, 0x17, 0xa0, 0x5a, 0x34, 0xa1, 0x97,
-	0x61, 0x2e, 0x61, 0x79, 0x65, 0x56, 0x9e, 0x40, 0x93, 0xc4, 0x8e, 0x27, 0xa6, 0xf2, 0xc7, 0xb1,
-	0x82, 0x88, 0x86, 0xde, 0xb4, 0x71, 0x8f, 0x6c, 0xc2, 0x84, 0x61, 0x76, 0xf4, 0xf3, 0xc7, 0x03,
-	0x89, 0xd1, 0x97, 0x53, 0xe3, 0x6c, 0x5d, 0x42, 0xcb, 0x67, 0x14, 0x7a, 0x45, 0x4c, 0x38, 0x07,
-	0x99, 0x61, 0x19, 0xcc, 0xe0, 0xb2, 0x5e, 0xef, 0xa7, 0xc7, 0x5d, 0xee, 0xc7, 0xa7, 0x9c, 0xb8,
-	0x24, 0xb5, 0x64, 0xca, 0x25, 0x4c, 0x63, 0x03, 0x32, 0xf1, 0x49, 0x27, 0xae, 0x95, 0x9f, 0xa4,
-	0xd7, 0x75, 0xdb, 0x30, 0xc5, 0x15, 0x9c, 0x89, 0xb8, 0x4b, 0x30, 0x99, 0x0c, 0x69, 0x39, 0x7a,
-	0xb6, 0xb9, 0xf1, 0xda, 0xc6, 0x08, 0x93, 0xd1, 0x12, 0x88, 0xf2, 0xab, 0x04, 0x99, 0x6a, 0x0b,
-	0x29, 0x3b, 0x6e, 0x07, 0x87, 0x3c, 0x6f, 0xba, 0xa7, 0xa6, 0x3c, 0xe4, 0xa9, 0xf9, 0xa3, 0x04,
-	0xe9, 0x9e, 0x5a, 0xee, 0x35, 0x2d, 0x83, 0x0d, 0xbd, 0x92, 0xa1, 0xfe, 0xd5, 0xbc, 0x94, 0xe1,
-	0x72, 0x4f, 0xde, 0x55, 0x6a, 0xfd, 0xa7, 0xb3, 0x26, 0x0f, 0x61, 0xc2, 0x43, 0xc3, 0x77, 0x69,
-	0x74, 0xfe, 0x66, 0x17, 0x8a, 0x83, 0xb0, 0x1d, 0x5f, 0xa6, 0xaa, 0x45, 0x44, 0x1a, 0x27, 0x54,
-	0x4c, 0x98, 0x88, 0x2d, 0xe4, 0x32, 0x10, 0xad, 0x5a, 0xdc, 0x58, 0x5f, 0xd3, 0xef, 0xad, 0x6d,
-	0xd4, 0xab, 0xe5, 0xda, 0x72, 0xad, 0x5a, 0x49, 0x8d, 0x10, 0x02, 0xb3, 0xdc, 0x5e, 0x7d, 0x50,
-	0xaf, 0x69, 0xd5, 0x4a, 0x4a, 0x22, 0x17, 0xe0, 0x3c, 0xb7, 0x2d, 0xd7, 0x56, 0x57, 0xab, 0x95,
-	0x94, 0x4c, 0x32, 0x70, 0x99, 0x9b, 0xca, 0xab, 0xeb, 0x1b, 0xd5, 0x8a, 0x5e, 0x7a, 0xa8, 0xaf,
-	0xdf, 0x5f, 0xab, 0x6a, 0xa9, 0x51, 0xe5, 0x2f, 0x09, 0xb2, 0x51, 0x3a, 0xd1, 0xb1, 0x28, 0xdb,
-	0x9e, 0x19, 0xd8, 0xac, 0xe4, 0xa1, 0xf1, 0x05, 0x7a, 0x65, 0x0f, 0x2d, 0x9b, 0x91, 0x02, 0x4c,
-	0x46, 0x87, 0xa7, 0xad, 0xfd, 0x89, 0x0f, 0xc7, 0xe7, 0x8c, 0x78, 0x41, 0x56, 0x20, 0xd5, 0xf4,
-	0xb0, 0x65, 0xbb, 0x81, 0xaf, 0x6f, 0xc7, 0x7f, 0x59, 0x5c, 0xf6, 0xd7, 0x3f, 0x44, 0xcd, 0x09,
-	0x14, 0xff, 0x9f, 0x23, 0x4b, 0x30, 0x4d, 0x71, 0x2f, 0xe1, 0x18, 0xe4, 0x29, 0x1b, 0x28, 0xee,
-	0x71, 0xb8, 0x72, 0x24, 0xc1, 0xb5, 0x7e, 0x65, 0x56, 0x70, 0xfb, 0xff, 0x51, 0xe5, 0xc2, 0x0f,
-	0x32, 0xcc, 0x7c, 0x16, 0xa0, 0x77, 0xb0, 0x81, 0x5e, 0xcb, 0x36, 0x91, 0x7c, 0x25, 0x41, 0xaa,
-	0xfb, 0x0d, 0x95, 0x2c, 0xbe, 0xc1, 0xc9, 0xe9, 0xfe, 0x44, 0x90, 0xb9, 0x73, 0x3a, 0x30, 0x7f,
-	0x27, 0x7e, 0x26, 0x25, 0x9f, 0x3c, 0xda, 0x6f, 0xcc, 0xe4, 0x54, 0x9c, 0xe2, 0x25, 0x3e, 0xb3,
-	0x74, 0x4a, 0x74, 0x9c, 0xd2, 0x2d, 0xa9, 0xf4, 0xbb, 0xfc, 0xcb, 0x61, 0x56, 0x7a, 0x7e, 0x98,
-	0x95, 0xfe, 0x3c, 0xcc, 0x4a, 0xdf, 0x1c, 0x65, 0x47, 0x9e, 0x1f, 0x65, 0x47, 0x5e, 0x1c, 0x65,
-	0x47, 0xe0, 0xa6, 0xe9, 0x3a, 0x03, 0xd0, 0x97, 0x66, 0xc4, 0xe7, 0x16, 0xcf, 0x65, 0x6e, 0x5d,
-	0x7a, 0xf4, 0x60, 0xc7, 0x66, 0x8d, 0x60, 0x3b, 0x74, 0xce, 0x99, 0xae, 0xef, 0xb8, 0x7e, 0xce,
-	0xc3, 0x5d, 0xe3, 0x00, 0xbd, 0x5c, 0x6b, 0x21, 0x59, 0x9a, 0x0d, 0xc3, 0xa6, 0x7e, 0xee, 0xe4,
-	0x8f, 0x5c, 0x8b, 0x7c, 0xd9, 0xca, 0x7f, 0x2b, 0x8f, 0xd5, 0xcb, 0xe5, 0xe2, 0x77, 0xb2, 0x52,
-	0x17, 0x59, 0x95, 0xc3, 0xac, 0xca, 0x49, 0x56, 0x3c, 0x13, 0x75, 0x33, 0xff, 0x5b, 0xdb, 0x69,
-	0x2b, 0x74, 0xda, 0x4a, 0x9c, 0xb6, 0xb8, 0xd3, 0xd6, 0x66, 0xfe, 0x50, 0x56, 0x4f, 0x76, 0xda,
-	0x5a, 0xa9, 0x97, 0xc4, 0xbf, 0xfc, 0xdf, 0xf2, 0x4d, 0x01, 0x28, 0x14, 0x42, 0x44, 0xf8, 0xcb,
-	0x21, 0x85, 0x02, 0xc7, 0x14, 0x0a, 0x9b, 0xf9, 0xed, 0x89, 0xe8, 0xc3, 0xce, 0xed, 0x7f, 0x03,
-	0x00, 0x00, 0xff, 0xff, 0x69, 0xe3, 0xc7, 0x9d, 0xc6, 0x13, 0x00, 0x00,
+	// 1381 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x58, 0xcb, 0x6e, 0xdb, 0x46,
+	0x17, 0x36, 0xe9, 0x4b, 0xec, 0x63, 0xc7, 0x56, 0x26, 0xf9, 0x13, 0x45, 0xf8, 0xa3, 0x26, 0x5c,
+	0x04, 0x6e, 0x81, 0x52, 0x91, 0x83, 0x6e, 0xe4, 0xb8, 0x80, 0x6e, 0x76, 0x85, 0x3a, 0xb6, 0x4a,
+	0x37, 0xce, 0x05, 0x0e, 0x08, 0x9a, 0x3c, 0xb1, 0x88, 0x9a, 0x43, 0x85, 0x1c, 0xca, 0x36, 0xfa,
+	0x0c, 0x2d, 0x8a, 0x3c, 0x42, 0x97, 0xed, 0xb2, 0x28, 0x0a, 0xf4, 0x09, 0xda, 0xae, 0xb2, 0x29,
+	0x10, 0x74, 0x55, 0xd8, 0x5d, 0x75, 0x9b, 0x75, 0x81, 0x82, 0xe4, 0x0c, 0xa5, 0x48, 0x56, 0xac,
+	0xd8, 0x0a, 0x10, 0x74, 0x23, 0x0c, 0xcf, 0x9c, 0xef, 0x3b, 0xd7, 0x39, 0x22, 0x07, 0x6e, 0x35,
+	0x91, 0x06, 0xce, 0xb6, 0x67, 0xe4, 0x4c, 0xd7, 0xc3, 0x9c, 0xe9, 0x3a, 0x4d, 0x97, 0x22, 0x65,
+	0x39, 0x23, 0x30, 0x99, 0xed, 0xd2, 0x5c, 0x2b, 0x2f, 0x96, 0x6a, 0xd3, 0x73, 0x99, 0x4b, 0x14,
+	0x81, 0x50, 0x43, 0x84, 0x9a, 0x20, 0x54, 0xa1, 0xd6, 0xca, 0x67, 0xae, 0xee, 0xb8, 0xee, 0xce,
+	0x2e, 0xe6, 0x22, 0xc4, 0x76, 0xf0, 0x24, 0x67, 0xd0, 0x83, 0x18, 0x9e, 0x51, 0x5e, 0x35, 0x68,
+	0xf8, 0x3e, 0xb2, 0xc8, 0x48, 0xb8, 0xe0, 0x3a, 0xf3, 0xfd, 0x9c, 0xb2, 0x70, 0x3f, 0xd4, 0xb5,
+	0x70, 0x9f, 0x6b, 0x66, 0x5f, 0xd5, 0xa4, 0x81, 0x13, 0xee, 0xd3, 0xc0, 0x89, 0xf7, 0x95, 0x8b,
+	0x70, 0xa1, 0x18, 0xbb, 0x55, 0x37, 0x3c, 0xc3, 0x41, 0x86, 0x9e, 0xaf, 0xe8, 0x30, 0xbb, 0x82,
+	0x14, 0x7d, 0xdb, 0x2f, 0xbb, 0x94, 0x21, 0x65, 0xe4, 0x2e, 0x4c, 0x34, 0xc3, 0x7d, 0x3f, 0x2d,
+	0x5d, 0x97, 0xe6, 0xa7, 0x17, 0x3e, 0x52, 0x4f, 0x0e, 0x52, 0xed, 0x21, 0xd6, 0x38, 0x89, 0xf2,
+	0x00, 0xae, 0xf0, 0xcd, 0x0d, 0x66, 0x30, 0x2c, 0x1d, 0xd4, 0x2c, 0x0d, 0x9f, 0x06, 0xe8, 0x33,
+	0xb2, 0x04, 0xb2, 0x6d, 0x71, 0x2b, 0x1f, 0xbe, 0x81, 0x95, 0x9a, 0xa5, 0xc9, 0xb6, 0xa5, 0x3c,
+	0x93, 0x20, 0xdd, 0x4b, 0xed, 0x37, 0x5d, 0xea, 0x23, 0x51, 0xe1, 0x1c, 0x07, 0xa6, 0xe5, 0xc8,
+	0xc0, 0x25, 0x35, 0xae, 0x83, 0x2a, 0xea, 0xa0, 0x16, 0xe9, 0x81, 0x26, 0x94, 0xc8, 0x32, 0x4c,
+	0x35, 0x5d, 0xdf, 0x0e, 0xd7, 0x7e, 0x7a, 0xf4, 0xfa, 0xe8, 0xfc, 0xf4, 0xc2, 0x7c, 0x5f, 0x97,
+	0xc2, 0x9c, 0xb7, 0xf2, 0x6a, 0x9d, 0x03, 0xb4, 0x36, 0x54, 0x79, 0xd8, 0xeb, 0x93, 0xdf, 0x1d,
+	0xef, 0xe8, 0xe9, 0xe2, 0x7d, 0x29, 0xc1, 0xd5, 0x63, 0xb8, 0x79, 0xc0, 0x67, 0x4b, 0x26, 0x59,
+	0xef, 0xce, 0xd7, 0x40, 0x65, 0xaf, 0x04, 0xcc, 0x6c, 0x74, 0xfa, 0x34, 0xfc, 0x84, 0xde, 0x80,
+	0xa9, 0xc4, 0x53, 0x72, 0x09, 0xc6, 0x6d, 0x4a, 0xd1, 0x8b, 0xe2, 0x9c, 0xd1, 0xe2, 0x07, 0xe5,
+	0x31, 0x00, 0x57, 0x59, 0x7b, 0x72, 0xd6, 0xae, 0x22, 0x29, 0x18, 0xf5, 0xf1, 0x69, 0x94, 0x84,
+	0x31, 0x2d, 0x5c, 0x2a, 0xff, 0xc8, 0x70, 0xa5, 0x33, 0xd0, 0x0a, 0xfa, 0xa6, 0x67, 0x37, 0xa3,
+	0x28, 0x6f, 0x87, 0x0e, 0x35, 0x03, 0xc6, 0xed, 0x5d, 0xeb, 0xb2, 0x17, 0x1f, 0xe4, 0x56, 0x5e,
+	0xdd, 0x34, 0x76, 0x03, 0xd4, 0x62, 0x5d, 0x72, 0x07, 0xa6, 0xdc, 0x80, 0x35, 0x03, 0xa6, 0xdb,
+	0x16, 0xcf, 0xf6, 0x7b, 0xfd, 0x80, 0xc5, 0x70, 0x51, 0xb3, 0xb4, 0xc9, 0x18, 0x51, 0xb3, 0xc8,
+	0x22, 0x80, 0x63, 0xec, 0xeb, 0xf1, 0x73, 0x7a, 0x34, 0x82, 0xff, 0xbf, 0x0b, 0x1e, 0x1e, 0xfa,
+	0x10, 0xec, 0xb8, 0x01, 0x65, 0xda, 0x94, 0x63, 0xec, 0xaf, 0x47, 0xea, 0x11, 0xd8, 0xa6, 0x02,
+	0x3c, 0x36, 0x10, 0xd8, 0xa6, 0x1c, 0x7c, 0x03, 0x66, 0x7c, 0x66, 0x78, 0x4c, 0x6f, 0xa0, 0xbd,
+	0xd3, 0x60, 0xe9, 0xf1, 0x28, 0x47, 0xd3, 0x91, 0xec, 0x93, 0x48, 0x44, 0xae, 0x01, 0x20, 0xb5,
+	0x84, 0xc2, 0x44, 0xa4, 0x30, 0x85, 0xd4, 0x6a, 0x6f, 0xfb, 0x0c, 0x9b, 0xba, 0x19, 0x52, 0xa7,
+	0xcf, 0xc5, 0xdb, 0xa1, 0xa4, 0x1c, 0x0a, 0xc2, 0xf2, 0x52, 0x97, 0x9a, 0x98, 0x9e, 0x8c, 0xcb,
+	0x1b, 0x3d, 0x28, 0xdf, 0xcb, 0x70, 0xa1, 0xa7, 0xd1, 0x44, 0x9d, 0xa4, 0xa4, 0x4e, 0xe4, 0x1e,
+	0xa4, 0xcc, 0xc0, 0xf3, 0x90, 0x32, 0x5d, 0xb4, 0x0f, 0xcf, 0xee, 0x07, 0x83, 0x36, 0x5e, 0xcd,
+	0xd2, 0xe6, 0x38, 0x87, 0x10, 0x85, 0x51, 0x53, 0xdc, 0x67, 0x3a, 0xf3, 0xec, 0x9d, 0x1d, 0xf4,
+	0xa2, 0x8c, 0x8f, 0x69, 0xd3, 0xa1, 0xec, 0xf3, 0x58, 0x44, 0xca, 0x30, 0x1b, 0x55, 0x56, 0xf7,
+	0xd0, 0x47, 0xaf, 0x85, 0xfe, 0x40, 0x99, 0x3d, 0x1f, 0x61, 0x34, 0x0e, 0x21, 0x55, 0x98, 0xe3,
+	0x5d, 0x91, 0xb0, 0x8c, 0x0f, 0xc0, 0x32, 0x1b, 0x83, 0x04, 0x8d, 0xf2, 0xb3, 0x04, 0x33, 0x9d,
+	0xd9, 0x22, 0x8f, 0x61, 0xda, 0x6a, 0x77, 0x2c, 0x6f, 0xd4, 0xc5, 0x37, 0x3d, 0xdd, 0x1d, 0x4d,
+	0xaf, 0x75, 0xf2, 0x91, 0x4f, 0x61, 0xdc, 0x0f, 0x0b, 0x72, 0xb6, 0xb1, 0x11, 0x73, 0x28, 0x5f,
+	0x42, 0xa6, 0x18, 0x9b, 0xeb, 0xd4, 0x30, 0x1b, 0x68, 0x05, 0xbb, 0xf8, 0x96, 0x23, 0x51, 0x10,
+	0xfe, 0xd7, 0x6b, 0xbc, 0x4a, 0x2d, 0xb2, 0x0a, 0xc0, 0xb9, 0xf4, 0xd3, 0x4e, 0x96, 0x29, 0x43,
+	0x2c, 0x95, 0x17, 0xd2, 0x71, 0x41, 0xde, 0xb7, 0x59, 0xc3, 0xf2, 0x8c, 0xbd, 0xe1, 0x1a, 0xeb,
+	0x9d, 0x66, 0xe4, 0x11, 0x5c, 0x14, 0xfd, 0xa5, 0x9b, 0xae, 0xe3, 0xd8, 0xcc, 0x41, 0x2a, 0xe6,
+	0xc8, 0xfb, 0xfd, 0xc6, 0x50, 0xc9, 0xd8, 0x35, 0xa8, 0x89, 0xe5, 0x04, 0xa0, 0x11, 0xc1, 0xd2,
+	0x96, 0x29, 0x5f, 0xcb, 0x90, 0xed, 0x1f, 0x5a, 0x7d, 0xd7, 0xa0, 0x6f, 0x3d, 0xbc, 0x0a, 0xcc,
+	0x26, 0xe1, 0xc5, 0x93, 0x79, 0x74, 0x90, 0xc9, 0x7c, 0x5e, 0x80, 0x6a, 0xd1, 0x84, 0x5e, 0x86,
+	0xb9, 0x84, 0xe5, 0x95, 0x59, 0x79, 0x02, 0x4d, 0x62, 0x3b, 0x9e, 0x98, 0xca, 0x1f, 0xc7, 0x26,
+	0x44, 0x34, 0xf4, 0xa6, 0x8d, 0x7b, 0x64, 0x13, 0x26, 0x0c, 0xb3, 0xa3, 0x9f, 0x3f, 0x1e, 0x28,
+	0x19, 0x7d, 0x39, 0x35, 0xce, 0xd6, 0x95, 0x68, 0xf9, 0x8c, 0x89, 0x5e, 0x11, 0x13, 0xce, 0x41,
+	0x66, 0x58, 0x06, 0x33, 0x78, 0x5a, 0xaf, 0xf7, 0xcb, 0xc7, 0x5d, 0xae, 0xc7, 0xa7, 0x9c, 0x78,
+	0x24, 0xb5, 0x64, 0xca, 0x25, 0x4c, 0x63, 0x03, 0x32, 0xf1, 0x49, 0x27, 0x9e, 0x95, 0x9f, 0xa4,
+	0xd7, 0x75, 0xdb, 0x30, 0x93, 0x2b, 0x38, 0x93, 0xe4, 0x2e, 0xc1, 0x64, 0x32, 0xa4, 0xe5, 0xe8,
+	0xdd, 0xe6, 0xc6, 0x6b, 0x1b, 0x23, 0x74, 0x46, 0x4b, 0x20, 0xca, 0xaf, 0x12, 0x64, 0xaa, 0x2d,
+	0xa4, 0xec, 0xb8, 0x0a, 0x0e, 0x79, 0xde, 0x74, 0x4f, 0x4d, 0x79, 0xc8, 0x53, 0xf3, 0x47, 0x09,
+	0xd2, 0x3d, 0xb1, 0xdc, 0x6b, 0x5a, 0x06, 0x1b, 0x7a, 0x24, 0x43, 0xfd, 0xab, 0x79, 0x29, 0xc3,
+	0xe5, 0x1e, 0xbf, 0xab, 0xd4, 0x7a, 0xa7, 0xbd, 0x26, 0x0f, 0x61, 0xc2, 0x43, 0xc3, 0x77, 0x69,
+	0x74, 0xfe, 0x66, 0x17, 0x8a, 0x83, 0xb0, 0x1d, 0x1f, 0xa6, 0xaa, 0x45, 0x44, 0x1a, 0x27, 0x54,
+	0x4c, 0x98, 0x88, 0x25, 0xe4, 0x32, 0x10, 0xad, 0x5a, 0xdc, 0x58, 0x5f, 0xd3, 0xef, 0xad, 0x6d,
+	0xd4, 0xab, 0xe5, 0xda, 0x72, 0xad, 0x5a, 0x49, 0x8d, 0x10, 0x02, 0xb3, 0x5c, 0x5e, 0x7d, 0x50,
+	0xaf, 0x69, 0xd5, 0x4a, 0x4a, 0x22, 0x17, 0xe0, 0x3c, 0x97, 0x2d, 0xd7, 0x56, 0x57, 0xab, 0x95,
+	0x94, 0x4c, 0x32, 0x70, 0x99, 0x8b, 0xca, 0xab, 0xeb, 0x1b, 0xd5, 0x8a, 0x5e, 0x7a, 0xa8, 0xaf,
+	0xdf, 0x5f, 0xab, 0x6a, 0xa9, 0xd1, 0xf0, 0xcc, 0xf6, 0x76, 0xbe, 0x38, 0x5e, 0xf4, 0x5d, 0xee,
+	0x97, 0xbf, 0x24, 0xc8, 0x46, 0x9e, 0x47, 0x07, 0xba, 0x6c, 0x7b, 0x66, 0x60, 0xb3, 0x92, 0x87,
+	0xc6, 0x17, 0xe8, 0x95, 0x3d, 0xb4, 0x6c, 0x46, 0x0a, 0x30, 0x19, 0x1d, 0xfb, 0xb6, 0xef, 0x27,
+	0xbe, 0xd6, 0x9f, 0x33, 0xe2, 0x05, 0x59, 0x81, 0x54, 0xd3, 0xc3, 0x96, 0xed, 0x06, 0xbe, 0xbe,
+	0x1d, 0xff, 0xd9, 0x72, 0xb7, 0x5f, 0xff, 0xfa, 0x37, 0x27, 0x50, 0xfc, 0x1f, 0x9a, 0x2c, 0xc1,
+	0x34, 0xc5, 0xbd, 0x84, 0x63, 0x90, 0xef, 0x03, 0xa0, 0xb8, 0xc7, 0xe1, 0xca, 0x91, 0x04, 0xd7,
+	0xfa, 0x85, 0x59, 0xc1, 0xed, 0xff, 0x46, 0x94, 0x0b, 0x3f, 0xc8, 0x30, 0xf3, 0x59, 0x80, 0xde,
+	0xc1, 0x06, 0x7a, 0x2d, 0xdb, 0x44, 0xf2, 0x95, 0x04, 0xa9, 0xee, 0x6f, 0x6b, 0xb2, 0xf8, 0x06,
+	0x9d, 0xd7, 0x7d, 0xb9, 0x91, 0xb9, 0x73, 0x3a, 0x30, 0xff, 0x9a, 0x7f, 0x26, 0x25, 0x97, 0x35,
+	0xed, 0x6f, 0x7d, 0x72, 0x2a, 0x4e, 0x71, 0xfd, 0x90, 0x59, 0x3a, 0x25, 0x3a, 0x76, 0xe9, 0x96,
+	0x54, 0xfa, 0x5d, 0xfe, 0xe5, 0x30, 0x2b, 0x3d, 0x3f, 0xcc, 0x4a, 0x7f, 0x1e, 0x66, 0xa5, 0x6f,
+	0x8e, 0xb2, 0x23, 0xcf, 0x8f, 0xb2, 0x23, 0x2f, 0x8e, 0xb2, 0x23, 0x70, 0xd3, 0x74, 0x9d, 0x01,
+	0xe8, 0x4b, 0x33, 0xe2, 0xa2, 0xc8, 0x73, 0x99, 0x5b, 0x97, 0x1e, 0x3d, 0xd8, 0xb1, 0x59, 0x23,
+	0xd8, 0x0e, 0x95, 0x73, 0xa6, 0xeb, 0x3b, 0xae, 0x9f, 0xf3, 0x70, 0xd7, 0x38, 0x40, 0x2f, 0xd7,
+	0x5a, 0x48, 0x96, 0x66, 0xc3, 0xb0, 0xa9, 0x9f, 0x3b, 0xf9, 0x7a, 0x6e, 0x91, 0x2f, 0x5b, 0xf9,
+	0x6f, 0xe5, 0xb1, 0x7a, 0xb9, 0x5c, 0xfc, 0x4e, 0x56, 0xea, 0xc2, 0xab, 0x72, 0xe8, 0x55, 0x39,
+	0xf1, 0x8a, 0x7b, 0xa2, 0x6e, 0xe6, 0x7f, 0x6b, 0x2b, 0x6d, 0x85, 0x4a, 0x5b, 0x89, 0xd2, 0x16,
+	0x57, 0xda, 0xda, 0xcc, 0x1f, 0xca, 0xea, 0xc9, 0x4a, 0x5b, 0x2b, 0xf5, 0x92, 0x78, 0x3f, 0xf9,
+	0x5b, 0xbe, 0x29, 0x00, 0x85, 0x42, 0x88, 0x08, 0x7f, 0x39, 0xa4, 0x50, 0xe0, 0x98, 0x42, 0x61,
+	0x33, 0xbf, 0x3d, 0x11, 0x5d, 0x49, 0xdd, 0xfe, 0x37, 0x00, 0x00, 0xff, 0xff, 0x66, 0x0b, 0x54,
+	0x5c, 0x80, 0x14, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -2606,6 +2660,53 @@ func (m *EventDutchAuctionEnded) MarshalToSizedBuffer(dAtA []byte) (int, error)
 	return len(dAtA) - i, nil
 }
 
+func (m *EventDutchAuctionWithdrawn) 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 *EventDutchAuctionWithdrawn) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *EventDutchAuctionWithdrawn) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.State != nil {
+		{
+			size, err := m.State.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintAuction(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x12
+	}
+	if m.AuctionId != nil {
+		{
+			size, err := m.AuctionId.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintAuction(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
 func (m *EventValueCircuitBreakerCredit) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -3106,6 +3207,23 @@ func (m *EventDutchAuctionEnded) Size() (n int) {
 	return n
 }
 
+func (m *EventDutchAuctionWithdrawn) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.AuctionId != nil {
+		l = m.AuctionId.Size()
+		n += 1 + l + sovAuction(uint64(l))
+	}
+	if m.State != nil {
+		l = m.State.Size()
+		n += 1 + l + sovAuction(uint64(l))
+	}
+	return n
+}
+
 func (m *EventValueCircuitBreakerCredit) Size() (n int) {
 	if m == nil {
 		return 0
@@ -5717,6 +5835,128 @@ func (m *EventDutchAuctionEnded) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *EventDutchAuctionWithdrawn) 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 ErrIntOverflowAuction
+			}
+			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: EventDutchAuctionWithdrawn: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: EventDutchAuctionWithdrawn: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field AuctionId", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowAuction
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthAuction
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthAuction
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.AuctionId == nil {
+				m.AuctionId = &AuctionId{}
+			}
+			if err := m.AuctionId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowAuction
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthAuction
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthAuction
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.State == nil {
+				m.State = &DutchAuctionState{}
+			}
+			if err := m.State.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipAuction(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthAuction
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func (m *EventValueCircuitBreakerCredit) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
diff --git a/relayer/chains/penumbra/core/component/dex/v1/dex.pb.go b/relayer/chains/penumbra/core/component/dex/v1/dex.pb.go
index b5a46d5b3..8296ae658 100644
--- a/relayer/chains/penumbra/core/component/dex/v1/dex.pb.go
+++ b/relayer/chains/penumbra/core/component/dex/v1/dex.pb.go
@@ -4461,6 +4461,9 @@ type DexParameters struct {
 	// If this number is exceeded, positions with the least
 	// inventory get evicted from the DEX.
 	MaxPositionsPerPair uint32 `protobuf:"varint,4,opt,name=max_positions_per_pair,json=maxPositionsPerPair,proto3" json:"max_positions_per_pair,omitempty"`
+	// The maximum number of routing and execution steps to be performed
+	// for a single pair
+	MaxExecutionBudget uint32 `protobuf:"varint,5,opt,name=max_execution_budget,json=maxExecutionBudget,proto3" json:"max_execution_budget,omitempty"`
 }
 
 func (m *DexParameters) Reset()         { *m = DexParameters{} }
@@ -4524,6 +4527,13 @@ func (m *DexParameters) GetMaxPositionsPerPair() uint32 {
 	return 0
 }
 
+func (m *DexParameters) GetMaxExecutionBudget() uint32 {
+	if m != nil {
+		return m.MaxExecutionBudget
+	}
+	return 0
+}
+
 type GenesisContent struct {
 	// The initial parameters for the DEX.
 	DexParams *DexParameters `protobuf:"bytes,1,opt,name=dex_params,json=dexParams,proto3" json:"dex_params,omitempty"`
@@ -4960,240 +4970,241 @@ func init() {
 }
 
 var fileDescriptor_ec17dcdac15b4004 = []byte{
-	// 3717 bytes of a gzipped FileDescriptorProto
+	// 3740 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5c, 0x5d, 0x6c, 0x23, 0x59,
-	0x56, 0x4e, 0x95, 0x9d, 0xd8, 0x3e, 0x89, 0xd3, 0xe9, 0x9b, 0x74, 0x26, 0xeb, 0x9d, 0xa4, 0xbb,
-	0xab, 0x77, 0xa1, 0x77, 0x60, 0x9d, 0x71, 0xf5, 0xf4, 0xcc, 0x6e, 0xa6, 0x97, 0xd9, 0xc4, 0xce,
-	0xdf, 0x4e, 0x77, 0xe2, 0xa9, 0x64, 0x32, 0xa3, 0x51, 0x33, 0x45, 0xc5, 0x75, 0x1d, 0x97, 0xc6,
-	0xae, 0xaa, 0xae, 0x2a, 0x3b, 0x8e, 0xc4, 0x8f, 0x06, 0xc1, 0x82, 0x40, 0xa0, 0x05, 0x21, 0xd0,
-	0x20, 0xf1, 0xc0, 0x4a, 0xbc, 0xf0, 0x06, 0x12, 0x6f, 0xa0, 0xd9, 0x17, 0x10, 0x1a, 0x24, 0xb4,
-	0xe2, 0x61, 0x17, 0x09, 0x09, 0xa1, 0x19, 0x24, 0x24, 0x9e, 0x78, 0xe3, 0x85, 0x07, 0x74, 0x7f,
-	0xaa, 0x5c, 0xe5, 0x94, 0xe3, 0xb2, 0xe3, 0x66, 0xd0, 0x68, 0x5f, 0xa6, 0x7d, 0x6f, 0x9d, 0xf3,
-	0xdd, 0x73, 0xce, 0x3d, 0xf7, 0xdc, 0x73, 0xcf, 0xbd, 0x13, 0xb8, 0x6f, 0x63, 0xb3, 0xdd, 0x3a,
-	0x75, 0xb4, 0xf5, 0x9a, 0xe5, 0xe0, 0xf5, 0x9a, 0xd5, 0xb2, 0x2d, 0x13, 0x9b, 0xde, 0xba, 0x8e,
-	0xbb, 0xeb, 0x9d, 0x12, 0xf9, 0xa7, 0x68, 0x3b, 0x96, 0x67, 0xa1, 0x35, 0x9f, 0xb2, 0x48, 0x28,
-	0x8b, 0x01, 0x65, 0x91, 0x90, 0x74, 0x4a, 0x05, 0x29, 0x8a, 0xa4, 0xb9, 0x2e, 0xf6, 0x08, 0x02,
-	0xfd, 0xc1, 0x30, 0x0a, 0x03, 0x47, 0xab, 0x63, 0x4c, 0x68, 0xeb, 0x18, 0x0f, 0xa3, 0x74, 0x6b,
-	0x14, 0xd5, 0xad, 0xf9, 0x98, 0x8f, 0x06, 0x52, 0x36, 0x0c, 0xdc, 0xd4, 0xb1, 0xae, 0xda, 0x96,
-	0xd5, 0xa4, 0x3c, 0xe1, 0x0e, 0xce, 0x7d, 0x27, 0xca, 0xfd, 0x01, 0xbe, 0x70, 0x09, 0x29, 0xf9,
-	0x97, 0x53, 0xac, 0x45, 0x29, 0xcc, 0x76, 0x8b, 0x10, 0x98, 0xed, 0x16, 0xff, 0xfe, 0x95, 0xe8,
-	0x77, 0xaf, 0xdb, 0xd0, 0xdc, 0x06, 0x21, 0x61, 0xbf, 0x2e, 0x8f, 0xe3, 0x5c, 0xd8, 0x9e, 0xb5,
-	0xee, 0x31, 0x3d, 0x3c, 0x5f, 0x0f, 0xe9, 0x1e, 0xcc, 0xbe, 0xf7, 0xe6, 0xd1, 0xb9, 0x66, 0x57,
-	0x1d, 0xcb, 0xaa, 0xa3, 0x25, 0x98, 0x36, 0x4c, 0x13, 0x3b, 0x2b, 0xc2, 0x1d, 0xe1, 0xfe, 0x9c,
-	0xc2, 0x1a, 0xd2, 0x7d, 0x58, 0x60, 0x44, 0xe5, 0xa6, 0x66, 0xb4, 0xae, 0xa2, 0xfc, 0x0d, 0x01,
-	0xd2, 0x84, 0x10, 0x6d, 0xc2, 0xb4, 0x4d, 0xe8, 0xe8, 0xe7, 0x59, 0xf9, 0x67, 0x8a, 0x57, 0xcf,
-	0x63, 0x31, 0x24, 0x84, 0xc2, 0x38, 0xd1, 0x23, 0x48, 0x9f, 0x5a, 0xfa, 0xc5, 0x4a, 0x9a, 0x22,
-	0xdc, 0x1f, 0x86, 0x40, 0xf8, 0xb7, 0x2c, 0xfd, 0x42, 0xa1, 0x5c, 0xd2, 0xdf, 0x08, 0x90, 0x0b,
-	0x44, 0x46, 0x3b, 0x51, 0x71, 0x5e, 0x4e, 0x26, 0x4e, 0x4f, 0x5d, 0x5f, 0xa6, 0x4d, 0x2e, 0x93,
-	0x48, 0x61, 0xbe, 0x9e, 0x44, 0x26, 0x0a, 0xd2, 0x13, 0x0c, 0x7d, 0x15, 0xe6, 0xb1, 0x6d, 0xd5,
-	0x1a, 0xaa, 0xde, 0x76, 0x34, 0xcf, 0xb0, 0xcc, 0x95, 0xcc, 0x1d, 0xe1, 0x7e, 0x5a, 0xc9, 0xd3,
-	0xde, 0x0a, 0xef, 0x94, 0xfe, 0x28, 0x05, 0xf9, 0x08, 0x3b, 0xda, 0x85, 0x9c, 0xd9, 0x6e, 0x36,
-	0x8d, 0xba, 0xc1, 0xad, 0x3e, 0x2b, 0x7f, 0x6d, 0xa0, 0x00, 0xc4, 0x53, 0x3b, 0xa5, 0xe2, 0x81,
-	0xcf, 0xa0, 0xf4, 0x78, 0xd1, 0x43, 0x48, 0xd5, 0x31, 0xe6, 0x3a, 0xdc, 0x1b, 0x08, 0x41, 0x96,
-	0x45, 0xa7, 0x54, 0xdc, 0xc1, 0x58, 0x21, 0xf4, 0xe8, 0x1d, 0x58, 0xb4, 0xda, 0x9e, 0xdd, 0xf6,
-	0xd4, 0x92, 0x5a, 0xb3, 0x5a, 0x2d, 0xc3, 0x6b, 0x61, 0xd3, 0x5b, 0x49, 0x51, 0x98, 0x9f, 0x0e,
-	0xc1, 0x50, 0x57, 0x2b, 0x7a, 0x4c, 0x82, 0x23, 0x4f, 0xf3, 0x70, 0x39, 0x20, 0x57, 0x6e, 0x32,
-	0x8c, 0x52, 0xaf, 0x2b, 0x04, 0x2c, 0x87, 0x81, 0xd3, 0x63, 0x01, 0xcb, 0x21, 0xe0, 0x63, 0x98,
-	0xe5, 0xc0, 0xba, 0xe6, 0x69, 0x2b, 0x33, 0x14, 0xf0, 0xc1, 0xb0, 0x49, 0xdb, 0xd2, 0xbc, 0x5a,
-	0x83, 0x98, 0xfe, 0x90, 0xf2, 0x56, 0x34, 0x4f, 0x53, 0xc0, 0x0a, 0x7e, 0x4b, 0xff, 0x21, 0x42,
-	0xd6, 0x77, 0x36, 0x74, 0x00, 0x73, 0x9e, 0xa3, 0xe9, 0x86, 0x79, 0xa6, 0xda, 0x9a, 0xe1, 0x24,
-	0x75, 0xf7, 0x63, 0xc6, 0x53, 0xd5, 0x0c, 0x47, 0x99, 0xf5, 0x7a, 0x0d, 0xf4, 0x0d, 0xc8, 0xe9,
-	0xb8, 0xe9, 0x69, 0x6a, 0x49, 0x35, 0xf8, 0x0c, 0xbd, 0xd8, 0x07, 0x46, 0x82, 0x40, 0xa7, 0x54,
-	0xdc, 0x6c, 0x59, 0x6d, 0xd3, 0x53, 0x32, 0x94, 0xbc, 0xb4, 0xdf, 0xe3, 0x94, 0x55, 0x83, 0x4f,
-	0x4a, 0x12, 0x4e, 0x79, 0x1f, 0x55, 0x61, 0xbe, 0x8e, 0xf1, 0x65, 0xd3, 0xf7, 0x7b, 0x17, 0x8b,
-	0xa9, 0xd4, 0x42, 0x4d, 0xcd, 0xac, 0x85, 0x8d, 0x9f, 0xaf, 0xe3, 0x50, 0x13, 0x6d, 0x43, 0xc6,
-	0xd6, 0x2e, 0x9a, 0x96, 0xa6, 0xaf, 0x4c, 0x27, 0x33, 0x08, 0x5d, 0xfd, 0x8c, 0x45, 0xf1, 0x79,
-	0xa5, 0x5f, 0x82, 0xd9, 0x50, 0x3f, 0xda, 0x05, 0x08, 0xc9, 0x28, 0x8c, 0xe6, 0x1e, 0x21, 0x56,
-	0xba, 0x04, 0x4d, 0x4a, 0x8e, 0x75, 0xd5, 0x3d, 0xd7, 0x6c, 0x6a, 0xe9, 0x39, 0x25, 0x1f, 0xf4,
-	0x92, 0x61, 0xa5, 0xff, 0x12, 0xd9, 0x12, 0xac, 0x36, 0x35, 0xc3, 0xf4, 0x70, 0xd7, 0xfb, 0x42,
-	0xcc, 0xf6, 0xb7, 0x21, 0x57, 0x23, 0x31, 0x45, 0x25, 0x31, 0x20, 0x9d, 0x3c, 0x06, 0x64, 0x29,
-	0xd7, 0x0e, 0xc6, 0xa8, 0x0c, 0x79, 0x86, 0xa0, 0xe9, 0xba, 0x83, 0x5d, 0x97, 0xcf, 0xf1, 0x5a,
-	0x1f, 0x0a, 0xdd, 0xcd, 0x88, 0x00, 0x8c, 0x4a, 0x99, 0xa3, 0x4c, 0xbc, 0x45, 0xf6, 0x0f, 0xc7,
-	0xc5, 0x58, 0xa7, 0xab, 0x72, 0x4e, 0x61, 0x0d, 0xe9, 0xc7, 0x02, 0x5b, 0x5b, 0xd5, 0xa6, 0x66,
-	0xa2, 0x63, 0x98, 0x27, 0x93, 0xa3, 0xda, 0xbe, 0xfd, 0xb9, 0xbd, 0x13, 0x85, 0xdd, 0x60, 0xd2,
-	0x94, 0xbc, 0x1b, 0x99, 0xc3, 0xbb, 0x30, 0x47, 0xbc, 0xfd, 0xb4, 0x69, 0x98, 0x64, 0x1e, 0xf8,
-	0xd4, 0xcf, 0xd6, 0x31, 0xde, 0xe2, 0x5d, 0xe8, 0x3e, 0x2c, 0xd0, 0x70, 0x1f, 0x10, 0xa9, 0x0e,
-	0xb5, 0xf1, 0x9c, 0x32, 0x4f, 0xfb, 0x7d, 0x42, 0x25, 0x86, 0xd2, 0xa5, 0x36, 0xed, 0xa7, 0x3c,
-	0x92, 0xfe, 0x49, 0x0c, 0xc5, 0xf3, 0xe7, 0xa8, 0x5e, 0x01, 0xb2, 0xb6, 0xe5, 0x1a, 0x74, 0x63,
-	0x11, 0xe9, 0xc6, 0x12, 0xb4, 0xfb, 0xe3, 0x61, 0x6a, 0x22, 0xf1, 0x30, 0x66, 0x43, 0x4b, 0xc7,
-	0x6c, 0x68, 0xb1, 0x46, 0x9d, 0x4e, 0x6c, 0xd4, 0x99, 0x58, 0xa3, 0xfe, 0x26, 0x30, 0x77, 0x39,
-	0x31, 0xf0, 0x39, 0x7a, 0x0c, 0x99, 0x8e, 0xe1, 0x1a, 0xa7, 0x4d, 0x9c, 0x74, 0x97, 0xf7, 0x59,
-	0x8b, 0x27, 0x8c, 0x6f, 0x6f, 0x4a, 0xf1, 0x21, 0xd0, 0x3e, 0xcc, 0x58, 0xb6, 0xf6, 0xac, 0xed,
-	0xef, 0x93, 0xeb, 0x89, 0xc1, 0x0e, 0x29, 0xdb, 0xde, 0x94, 0xc2, 0x01, 0x0a, 0xff, 0x93, 0x86,
-	0x0c, 0x1f, 0x01, 0x7d, 0x03, 0xd2, 0x34, 0xe0, 0x30, 0x09, 0xbf, 0x92, 0x04, 0x54, 0xa1, 0x1c,
-	0x31, 0xee, 0x92, 0x9a, 0x80, 0xbb, 0x6c, 0x02, 0x5b, 0xd7, 0xaa, 0xd7, 0xe5, 0xc1, 0xe0, 0xa7,
-	0xfa, 0xf0, 0x78, 0x42, 0xc9, 0xc2, 0x98, 0xe9, 0x6a, 0x35, 0x32, 0x9b, 0xfb, 0xba, 0x92, 0xa1,
-	0x7c, 0xc7, 0x5d, 0xd4, 0x80, 0xe5, 0x53, 0xe2, 0x22, 0x34, 0x92, 0xaa, 0x61, 0x07, 0x5b, 0x1a,
-	0xdf, 0xc1, 0x16, 0x4f, 0x2f, 0x77, 0xa2, 0x27, 0x90, 0xf5, 0x33, 0x90, 0x95, 0x35, 0x8a, 0x2d,
-	0x0f, 0x4e, 0x80, 0x22, 0x69, 0x37, 0x49, 0x85, 0x2c, 0x0f, 0x93, 0xf9, 0x51, 0x32, 0x3c, 0x03,
-	0x09, 0xc1, 0xc9, 0x2b, 0xb7, 0xaf, 0x0b, 0x27, 0xa3, 0xef, 0xc0, 0x02, 0xdd, 0x21, 0xd5, 0x92,
-	0xda, 0xc2, 0x9e, 0x46, 0x2d, 0x70, 0x9f, 0xc2, 0xde, 0x19, 0xb4, 0x91, 0x3e, 0xe1, 0x74, 0xca,
-	0x3c, 0xed, 0x2a, 0xf9, 0xed, 0x1e, 0x96, 0xdc, 0xc3, 0xfa, 0xda, 0x48, 0x58, 0xb2, 0xdf, 0x2e,
-	0xfc, 0x28, 0x05, 0x33, 0xcc, 0x27, 0xaf, 0xe1, 0x7d, 0xff, 0x77, 0x93, 0xbc, 0x0b, 0xf3, 0x41,
-	0x9a, 0xd9, 0xd1, 0x9a, 0x6d, 0xcc, 0xa7, 0xfa, 0xee, 0x20, 0xc5, 0x4f, 0x08, 0x11, 0x9d, 0x8a,
-	0x39, 0x3e, 0xb3, 0xb4, 0x27, 0x04, 0x24, 0x73, 0xa0, 0xdb, 0x23, 0x02, 0xc9, 0x0c, 0xe8, 0xff,
-	0xe9, 0xc4, 0x6e, 0xcd, 0x42, 0x8e, 0xce, 0x46, 0xc7, 0xc0, 0xe7, 0xd2, 0x3f, 0xa6, 0x43, 0xfb,
-	0x0b, 0x8d, 0x87, 0x6f, 0xf5, 0xc7, 0xc3, 0x87, 0x89, 0x8f, 0x2b, 0x83, 0x82, 0xe2, 0x41, 0x5f,
-	0x50, 0x7c, 0x65, 0x34, 0xc4, 0x4b, 0x91, 0xf1, 0x2f, 0xc5, 0x5e, 0x64, 0xdc, 0x03, 0xa0, 0xda,
-	0xd0, 0xb0, 0x32, 0xf4, 0x7c, 0xd3, 0x8f, 0xaf, 0x50, 0x53, 0xb0, 0xc3, 0x5e, 0x38, 0x4c, 0x88,
-	0x93, 0x0d, 0x13, 0xa9, 0xeb, 0x87, 0x89, 0x37, 0x20, 0x43, 0xf5, 0x1c, 0x39, 0xe0, 0xce, 0x10,
-	0xb6, 0xe3, 0x6e, 0x41, 0x09, 0x96, 0xf3, 0xc4, 0x4c, 0xb6, 0x75, 0x13, 0x6e, 0xf4, 0x90, 0x98,
-	0x43, 0x7d, 0x28, 0xc0, 0xec, 0x71, 0x24, 0x57, 0xcd, 0xf0, 0x55, 0xc0, 0x47, 0xba, 0x3d, 0xc8,
-	0x61, 0x37, 0xc9, 0x0f, 0x22, 0x30, 0xf3, 0xfd, 0x1e, 0xa7, 0xcc, 0xa7, 0x23, 0x21, 0xa7, 0x2c,
-	0xfd, 0x0a, 0x2c, 0x56, 0x0c, 0x07, 0xd7, 0x3c, 0xac, 0x87, 0x45, 0x79, 0x08, 0xd3, 0xae, 0xa7,
-	0x39, 0x5e, 0x52, 0x41, 0x18, 0x35, 0x2a, 0x41, 0x0a, 0x9b, 0x7a, 0x52, 0x19, 0x08, 0xad, 0xf4,
-	0x71, 0x1a, 0x16, 0x63, 0x22, 0x17, 0x7a, 0x08, 0x19, 0x9e, 0xb8, 0x73, 0x19, 0xae, 0x4e, 0xbe,
-	0x67, 0x58, 0xda, 0xde, 0x63, 0x93, 0x13, 0x65, 0xfb, 0x8c, 0x4d, 0x46, 0xaf, 0x41, 0xb6, 0xa9,
-	0xb5, 0x4e, 0x75, 0x32, 0x5c, 0xa2, 0x5c, 0x9f, 0x51, 0x97, 0x42, 0x8c, 0x32, 0x77, 0xb6, 0x44,
-	0x8c, 0x32, 0x7a, 0x1d, 0xa0, 0x6d, 0xd6, 0x8d, 0x66, 0x13, 0xeb, 0x6a, 0x89, 0xe7, 0xf7, 0x57,
-	0xb3, 0xe6, 0x7c, 0xfa, 0x52, 0x84, 0x59, 0xe6, 0xa7, 0xee, 0x84, 0xcc, 0x32, 0x5a, 0x86, 0x99,
-	0x06, 0x36, 0xce, 0x1a, 0x1e, 0x2f, 0x8b, 0xf0, 0xd6, 0xa5, 0xa3, 0x57, 0xf6, 0x9a, 0x47, 0xaf,
-	0x57, 0xe1, 0x16, 0xcb, 0x5a, 0xa9, 0x6f, 0x10, 0x58, 0x3e, 0x6c, 0x8e, 0x0c, 0xbb, 0x25, 0xae,
-	0x08, 0xca, 0x22, 0x25, 0x38, 0xe2, 0xdf, 0xf7, 0x98, 0x1c, 0x45, 0x58, 0x74, 0x6b, 0x9e, 0xea,
-	0xe7, 0xd4, 0xaa, 0xed, 0xe0, 0xba, 0xd1, 0x5d, 0x01, 0x2a, 0xec, 0x4d, 0xb7, 0xe6, 0x55, 0xf9,
-	0x97, 0x2a, 0xfd, 0x20, 0xfd, 0x99, 0x00, 0x37, 0xb8, 0x10, 0x3b, 0x6d, 0x93, 0xae, 0x65, 0xf4,
-	0x16, 0xe4, 0x02, 0x41, 0xb9, 0xff, 0x24, 0xd8, 0x3f, 0x1d, 0xdc, 0x87, 0xa3, 0xf4, 0x50, 0xd0,
-	0x1b, 0x90, 0xa6, 0x66, 0x11, 0x47, 0x37, 0x0b, 0x65, 0x24, 0x4b, 0x2d, 0x66, 0x08, 0xb4, 0xc0,
-	0x6a, 0x45, 0x44, 0xc8, 0x3c, 0x2b, 0x03, 0xbd, 0x04, 0x82, 0x9d, 0xc8, 0x7b, 0x05, 0x9b, 0xd0,
-	0x3e, 0x4b, 0xe4, 0xb1, 0xc2, 0x33, 0xa9, 0x0e, 0x59, 0x05, 0xbb, 0xd8, 0xe9, 0x60, 0x17, 0xfd,
-	0x2c, 0x88, 0x4e, 0xb2, 0x95, 0x25, 0x3a, 0x25, 0x4a, 0x9d, 0x6c, 0x41, 0x89, 0x8e, 0x2c, 0xfd,
-	0xbe, 0x08, 0x59, 0x7f, 0x8e, 0xd0, 0x26, 0xa4, 0xec, 0x86, 0xc1, 0x47, 0x5a, 0x4f, 0x68, 0xb5,
-	0xc0, 0xfe, 0x84, 0x97, 0x1c, 0x64, 0x4d, 0xcb, 0xac, 0x61, 0x7e, 0x90, 0x64, 0x0d, 0x54, 0xa6,
-	0x21, 0xca, 0xc3, 0x49, 0x93, 0x74, 0x5f, 0x22, 0x5a, 0xb6, 0x50, 0x18, 0x2f, 0xaa, 0x40, 0xd6,
-	0xe1, 0x26, 0x49, 0x5a, 0x05, 0xf5, 0x4d, 0xa8, 0x04, 0x9c, 0x48, 0x22, 0xc7, 0x75, 0xcb, 0xc5,
-	0xaa, 0x65, 0xaa, 0x64, 0x95, 0xd1, 0xe5, 0x9c, 0x55, 0x66, 0x69, 0xe7, 0xa1, 0xb9, 0x63, 0x34,
-	0x9b, 0x52, 0x19, 0xc0, 0x97, 0x60, 0x5f, 0x8f, 0xaf, 0xed, 0xa2, 0xdb, 0x30, 0xab, 0x35, 0x3d,
-	0xf5, 0x14, 0xd7, 0x1a, 0x0f, 0xe4, 0x16, 0x55, 0x37, 0xa7, 0x80, 0xd6, 0xf4, 0xb6, 0x58, 0x8f,
-	0xf4, 0xb7, 0x22, 0xe4, 0x23, 0x7a, 0xa0, 0xb7, 0x7d, 0x2b, 0x10, 0xa0, 0x79, 0xf9, 0x8d, 0x91,
-	0xac, 0x10, 0x6d, 0x6d, 0x9b, 0xed, 0x96, 0x6f, 0x97, 0x02, 0x64, 0x5d, 0xfc, 0xac, 0x8d, 0x7d,
-	0xab, 0xa7, 0x95, 0xa0, 0x2d, 0xfd, 0x40, 0x80, 0x9b, 0x97, 0x18, 0xd1, 0x3d, 0xb8, 0x5d, 0x3d,
-	0x3c, 0xda, 0x3f, 0xde, 0x3f, 0x3c, 0x50, 0x8f, 0x8e, 0x37, 0x8f, 0xb7, 0xd5, 0xed, 0x83, 0xb7,
-	0x9f, 0xa8, 0x6f, 0x1f, 0x1c, 0x55, 0xb7, 0xcb, 0xfb, 0x3b, 0xfb, 0xdb, 0x95, 0x85, 0x29, 0xb4,
-	0x06, 0x85, 0x38, 0xa2, 0xc3, 0xea, 0xf6, 0xc1, 0x76, 0x65, 0x41, 0x18, 0xf4, 0xbd, 0xfc, 0xf8,
-	0xf0, 0x68, 0xbb, 0xb2, 0x20, 0xa2, 0xbb, 0xb0, 0x1a, 0xf7, 0xfd, 0x9d, 0xfd, 0xe3, 0xbd, 0x8a,
-	0xb2, 0xf9, 0xce, 0xc1, 0x42, 0x0a, 0xdd, 0x83, 0x2f, 0xc7, 0x43, 0x6c, 0xee, 0x3f, 0xd9, 0xae,
-	0x2c, 0xa4, 0x0b, 0x62, 0x56, 0x90, 0x3e, 0x12, 0x60, 0xfa, 0xb1, 0x7d, 0x50, 0xf7, 0xd0, 0x9b,
-	0x30, 0x1b, 0x04, 0x1a, 0x43, 0xe7, 0x6e, 0xfa, 0x52, 0x52, 0x2b, 0xee, 0xeb, 0x0a, 0xd8, 0xbd,
-	0x59, 0x0d, 0x5c, 0x52, 0x1c, 0xdf, 0x25, 0xa5, 0x63, 0x98, 0xf3, 0xfb, 0x0f, 0x6d, 0x6c, 0x12,
-	0x17, 0x0d, 0xca, 0x0d, 0x42, 0x32, 0x17, 0xf5, 0xf9, 0x7b, 0x85, 0x09, 0xe9, 0x69, 0xcf, 0x71,
-	0xca, 0xc4, 0x2b, 0x27, 0xaa, 0xb8, 0xf4, 0x63, 0x01, 0x16, 0xfc, 0x4f, 0xef, 0x18, 0x5e, 0x43,
-	0x77, 0xb4, 0xf3, 0xc9, 0x9a, 0xf6, 0x3d, 0x58, 0xf4, 0x97, 0x5b, 0xb8, 0x8c, 0x2a, 0x8e, 0x5a,
-	0x46, 0x45, 0x3e, 0x4a, 0xa8, 0x96, 0x1a, 0x76, 0xf6, 0x54, 0x9f, 0xb3, 0xff, 0xb5, 0x00, 0x8b,
-	0x81, 0x39, 0xf1, 0xb9, 0xe6, 0xe8, 0x2c, 0x03, 0x9e, 0xa8, 0x72, 0xef, 0x02, 0x72, 0x28, 0xf6,
-	0xf5, 0x74, 0xbb, 0xc9, 0x41, 0x7a, 0x5d, 0xd2, 0x77, 0x79, 0x4d, 0x6c, 0xbb, 0x8b, 0x6b, 0x6d,
-	0x1a, 0x8f, 0xdf, 0x84, 0x19, 0xcf, 0xd1, 0x6a, 0xd8, 0x5d, 0x11, 0xee, 0xa4, 0x92, 0x6c, 0x8b,
-	0x11, 0x76, 0x12, 0xa0, 0x6b, 0x58, 0xe1, 0x10, 0xe8, 0x01, 0x09, 0x63, 0x76, 0xdb, 0x97, 0x75,
-	0xf5, 0xca, 0x73, 0x9f, 0xc2, 0x68, 0xd1, 0x43, 0x98, 0x61, 0x99, 0x3a, 0x8f, 0xdc, 0x43, 0xb8,
-	0x38, 0x71, 0xe1, 0x11, 0x4c, 0xd3, 0xc1, 0xc9, 0xa0, 0xec, 0xb0, 0xc9, 0x14, 0x18, 0x36, 0x28,
-	0xa5, 0x95, 0x3e, 0x16, 0x61, 0xa9, 0xdf, 0x43, 0x69, 0x8d, 0x30, 0xbc, 0x03, 0x08, 0x63, 0xef,
-	0x00, 0x7d, 0xee, 0x20, 0x5e, 0xcb, 0x1d, 0xfc, 0x4c, 0x23, 0x35, 0x66, 0xa6, 0x11, 0x71, 0xe8,
-	0x74, 0xd4, 0xa1, 0xd1, 0x6b, 0x90, 0xe1, 0x6e, 0xb2, 0x32, 0x9d, 0xc4, 0x7e, 0x3e, 0xb5, 0xa4,
-	0xc2, 0x0b, 0x31, 0x0b, 0x61, 0x72, 0x36, 0x94, 0x7e, 0x4d, 0x80, 0x42, 0x5c, 0x0d, 0x83, 0x48,
-	0xee, 0x7a, 0xa1, 0xb4, 0x55, 0xbc, 0x32, 0x6d, 0x4d, 0x5d, 0x2f, 0x6d, 0x95, 0xea, 0xf0, 0xe5,
-	0x58, 0x29, 0x5c, 0xdb, 0x32, 0x5d, 0x8c, 0x76, 0x21, 0x4d, 0x4b, 0x0a, 0xc2, 0xf8, 0x45, 0x19,
-	0x0a, 0x20, 0x7d, 0x57, 0x80, 0xa5, 0xc8, 0xda, 0x1a, 0xa6, 0xe8, 0x49, 0xac, 0xa2, 0x43, 0x25,
-	0x88, 0x39, 0xde, 0x45, 0x15, 0x6e, 0xc1, 0xad, 0x3e, 0x39, 0xb8, 0xaa, 0x7e, 0x3d, 0x14, 0xfb,
-	0x5f, 0x46, 0x29, 0x9f, 0xf7, 0xe0, 0x68, 0x3d, 0x34, 0x68, 0x4a, 0x5f, 0x87, 0xc5, 0x4d, 0xe7,
-	0x34, 0xa9, 0xd6, 0xc4, 0x2b, 0x96, 0xa2, 0xf4, 0xcf, 0x53, 0xba, 0x81, 0x62, 0xfc, 0x85, 0xd0,
-	0x67, 0x25, 0xd7, 0x17, 0xfc, 0x2e, 0xcc, 0xd1, 0x03, 0x8e, 0x1a, 0xe1, 0x9b, 0xa5, 0x7d, 0xfc,
-	0x44, 0xb3, 0x0a, 0x80, 0x4d, 0xdd, 0x27, 0x60, 0x5b, 0x4c, 0x0e, 0x9b, 0xfa, 0x5e, 0xfc, 0xc4,
-	0xa6, 0x27, 0x34, 0xb1, 0xff, 0x2a, 0xc0, 0x72, 0xbf, 0xcc, 0x9f, 0x87, 0xf1, 0x9e, 0x9b, 0xe7,
-	0xbe, 0x1b, 0x75, 0x8d, 0xc9, 0x4d, 0x89, 0xf4, 0xeb, 0x02, 0xdc, 0xea, 0x83, 0xfe, 0x5c, 0xdc,
-	0x6e, 0x0b, 0xbe, 0xf4, 0xd8, 0x78, 0xd6, 0x36, 0x74, 0xc3, 0xbb, 0xf0, 0xa3, 0x6f, 0xa0, 0xe6,
-	0x57, 0x61, 0xde, 0x30, 0x6b, 0xcd, 0xb6, 0x8e, 0x55, 0x7a, 0xd2, 0xd0, 0xa9, 0xe7, 0x64, 0x95,
-	0x3c, 0xef, 0xa5, 0x89, 0x9e, 0x2e, 0xbd, 0x07, 0x85, 0x38, 0x0c, 0xae, 0xcf, 0xa3, 0x48, 0x3c,
-	0x4b, 0x9e, 0x5a, 0xb2, 0x20, 0xf6, 0x01, 0xbc, 0x78, 0x09, 0x7b, 0xeb, 0x62, 0x5f, 0xf7, 0x45,
-	0x9c, 0xe4, 0xbe, 0x28, 0xfd, 0x3c, 0xac, 0x0e, 0x18, 0x6c, 0x22, 0xba, 0x34, 0x63, 0xe0, 0xdd,
-	0x2b, 0x95, 0x49, 0x5d, 0x43, 0x99, 0xf7, 0x61, 0x6d, 0xd0, 0x68, 0x13, 0xd1, 0xe6, 0x7b, 0x02,
-	0xdc, 0x89, 0x1b, 0xa0, 0xea, 0x18, 0x35, 0xec, 0x6b, 0xd4, 0xbf, 0x30, 0xc5, 0xc9, 0x2c, 0x4c,
-	0x72, 0xbc, 0x6d, 0x1a, 0x2d, 0xc3, 0xa3, 0x07, 0xe1, 0xb4, 0xc2, 0x1a, 0xd2, 0x9f, 0x08, 0x70,
-	0xf7, 0x0a, 0x91, 0x26, 0xa1, 0x36, 0xda, 0x00, 0x71, 0x2c, 0x3f, 0x13, 0x0d, 0x5d, 0x52, 0x21,
-	0x7f, 0x64, 0x3b, 0x58, 0x0b, 0x26, 0xfc, 0x20, 0xd6, 0x3c, 0xe3, 0xa7, 0x16, 0x7f, 0x27, 0xc2,
-	0xbc, 0x3f, 0x02, 0xd7, 0xf6, 0x5d, 0x58, 0x3a, 0xc5, 0xae, 0xa7, 0x96, 0x54, 0xcf, 0x52, 0x65,
-	0x75, 0xec, 0x93, 0xde, 0x02, 0x41, 0x29, 0x1d, 0x5b, 0x72, 0x50, 0x78, 0xf1, 0x91, 0x65, 0x82,
-	0x5c, 0x52, 0x23, 0x57, 0xd6, 0x23, 0x23, 0xcb, 0xc7, 0x56, 0x29, 0x40, 0x7e, 0x03, 0x56, 0x35,
-	0xdb, 0x76, 0xac, 0xae, 0x8a, 0xeb, 0x75, 0x5c, 0xf3, 0x8c, 0x0e, 0x56, 0x6d, 0x32, 0x87, 0x5c,
-	0x0b, 0x1a, 0x4e, 0x05, 0x65, 0x85, 0x11, 0x6d, 0xfb, 0x34, 0x74, 0x9a, 0x89, 0x88, 0x57, 0x00,
-	0x30, 0x61, 0x69, 0x1c, 0x1b, 0x00, 0x40, 0x24, 0x91, 0x7e, 0x94, 0x82, 0xa5, 0x23, 0xa3, 0xd5,
-	0x6e, 0x6a, 0x1e, 0xad, 0xa7, 0x05, 0x0e, 0x1d, 0x1c, 0x48, 0x84, 0x11, 0x0e, 0x24, 0xaf, 0x05,
-	0x07, 0x92, 0xa4, 0xc5, 0x73, 0x46, 0x8e, 0x4e, 0x20, 0xe3, 0x58, 0x6d, 0xcf, 0x30, 0xcf, 0xf8,
-	0x96, 0xf6, 0x68, 0xe8, 0x26, 0x10, 0x23, 0x74, 0x51, 0x61, 0x18, 0x8a, 0x0f, 0x56, 0xf8, 0x6f,
-	0x01, 0x32, 0xbc, 0x13, 0xfd, 0x02, 0x64, 0x74, 0x5c, 0xd7, 0xda, 0x4d, 0x5f, 0xa7, 0xca, 0x75,
-	0xc6, 0x28, 0x56, 0x18, 0xd6, 0xde, 0x94, 0xe2, 0xc3, 0xa2, 0x33, 0x00, 0xd7, 0x30, 0xcf, 0x9a,
-	0x58, 0x6d, 0x58, 0x7e, 0xdd, 0x71, 0xe7, 0x5a, 0x83, 0x1c, 0x51, 0xb8, 0x3d, 0xcb, 0xde, 0x9b,
-	0x52, 0x72, 0xae, 0xdf, 0x28, 0xcc, 0x42, 0x2e, 0xf8, 0x52, 0xc8, 0x41, 0x86, 0xcb, 0xb2, 0x95,
-	0x83, 0x8c, 0x8b, 0x3d, 0xc2, 0x29, 0x7d, 0x44, 0xd2, 0xac, 0x28, 0x34, 0x5f, 0x28, 0xdb, 0xc1,
-	0x24, 0x8d, 0xb5, 0xdf, 0xfa, 0x53, 0xf6, 0x4d, 0xc8, 0xfa, 0x95, 0xf0, 0x64, 0x87, 0xd6, 0x80,
-	0x5c, 0xfa, 0x53, 0x11, 0x72, 0xdb, 0x1d, 0x6c, 0x7a, 0xf4, 0xf9, 0xe5, 0x17, 0xe3, 0x59, 0x1a,
-	0xbf, 0x93, 0x1a, 0xfb, 0x49, 0x20, 0xcd, 0x85, 0x42, 0xf5, 0x86, 0x7f, 0x11, 0x61, 0x3e, 0xb0,
-	0x11, 0xab, 0x94, 0x4c, 0xda, 0x50, 0x03, 0x1e, 0x49, 0x8a, 0xcf, 0xeb, 0x91, 0x64, 0xea, 0xda,
-	0x8f, 0x24, 0x23, 0xcf, 0x4a, 0xd3, 0xe3, 0x3f, 0x2b, 0x95, 0xfe, 0x41, 0x84, 0x9b, 0xd4, 0xba,
-	0x91, 0x02, 0xe1, 0x44, 0x4b, 0x51, 0x13, 0xde, 0xf2, 0xd0, 0xeb, 0x00, 0x41, 0xdd, 0x2e, 0xd9,
+	0x56, 0xee, 0x2a, 0x3b, 0xb1, 0x7d, 0x12, 0xa7, 0xd3, 0x37, 0xe9, 0x9e, 0xac, 0x77, 0x92, 0xee,
+	0xae, 0xde, 0x85, 0xde, 0x81, 0x75, 0xda, 0xd5, 0xd3, 0x33, 0xbb, 0x99, 0x5e, 0x66, 0x13, 0x3b,
+	0x7f, 0x3b, 0xdd, 0x89, 0xa7, 0x92, 0xc9, 0x8c, 0x46, 0xcd, 0x14, 0x65, 0xd7, 0x75, 0x5c, 0x1a,
+	0xbb, 0xaa, 0xba, 0xaa, 0xec, 0x38, 0x12, 0x3f, 0x1a, 0x04, 0x0b, 0x02, 0x81, 0x16, 0x84, 0x40,
+	0x83, 0xc4, 0x03, 0x2b, 0xf1, 0xc2, 0x1b, 0x48, 0xbc, 0x81, 0x66, 0x5f, 0x40, 0x68, 0x91, 0xd0,
+	0x8a, 0x87, 0x5d, 0x24, 0x24, 0x84, 0x66, 0x90, 0x90, 0x78, 0xe2, 0x8d, 0x97, 0x7d, 0x40, 0xf7,
+	0xa7, 0xca, 0x55, 0x4e, 0x39, 0x2e, 0x3b, 0x6e, 0x16, 0x8d, 0x78, 0x99, 0xf6, 0xbd, 0x75, 0xce,
+	0x77, 0xcf, 0x39, 0xf7, 0xdc, 0x73, 0xcf, 0x3d, 0xf7, 0x4e, 0xe0, 0xbe, 0x8d, 0xcd, 0x4e, 0xbb,
+	0xe6, 0x68, 0xeb, 0x75, 0xcb, 0xc1, 0xeb, 0x75, 0xab, 0x6d, 0x5b, 0x26, 0x36, 0xbd, 0x75, 0x1d,
+	0xf7, 0xd6, 0xbb, 0x25, 0xf2, 0x4f, 0xd1, 0x76, 0x2c, 0xcf, 0x42, 0x6b, 0x3e, 0x65, 0x91, 0x50,
+	0x16, 0x03, 0xca, 0x22, 0x21, 0xe9, 0x96, 0x0a, 0x52, 0x14, 0x49, 0x73, 0x5d, 0xec, 0x11, 0x04,
+	0xfa, 0x83, 0x61, 0x14, 0x86, 0x8e, 0xd6, 0xc0, 0x98, 0xd0, 0x36, 0x30, 0x1e, 0x45, 0xe9, 0xd6,
+	0x29, 0xaa, 0x5b, 0xf7, 0x31, 0x1f, 0x0f, 0xa5, 0x6c, 0x1a, 0xb8, 0xa5, 0x63, 0x5d, 0xb5, 0x2d,
+	0xab, 0x45, 0x79, 0xc2, 0x1d, 0x9c, 0xfb, 0x4e, 0x94, 0xfb, 0x43, 0x7c, 0xee, 0x12, 0x52, 0xf2,
+	0x2f, 0xa7, 0x58, 0x8b, 0x52, 0x98, 0x9d, 0x36, 0x21, 0x30, 0x3b, 0x6d, 0xfe, 0xfd, 0x4b, 0xd1,
+	0xef, 0x5e, 0xaf, 0xa9, 0xb9, 0x4d, 0x42, 0xc2, 0x7e, 0x5d, 0x1c, 0xc7, 0x39, 0xb7, 0x3d, 0x6b,
+	0xdd, 0x63, 0x7a, 0x78, 0xbe, 0x1e, 0xd2, 0x3d, 0x98, 0x7b, 0xff, 0xad, 0xa3, 0x33, 0xcd, 0xae,
+	0x3a, 0x96, 0xd5, 0x40, 0xcb, 0x30, 0x63, 0x98, 0x26, 0x76, 0x56, 0x84, 0x3b, 0xc2, 0xfd, 0x79,
+	0x85, 0x35, 0xa4, 0xfb, 0xb0, 0xc8, 0x88, 0xca, 0x2d, 0xcd, 0x68, 0x5f, 0x46, 0xf9, 0x1b, 0x02,
+	0xa4, 0x09, 0x21, 0xda, 0x84, 0x19, 0x9b, 0xd0, 0xd1, 0xcf, 0x73, 0xf2, 0xcf, 0x14, 0x2f, 0x9f,
+	0xc7, 0x62, 0x48, 0x08, 0x85, 0x71, 0xa2, 0xc7, 0x90, 0xae, 0x59, 0xfa, 0xf9, 0x4a, 0x9a, 0x22,
+	0xdc, 0x1f, 0x85, 0x40, 0xf8, 0xb7, 0x2c, 0xfd, 0x5c, 0xa1, 0x5c, 0xd2, 0xdf, 0x08, 0x90, 0x0b,
+	0x44, 0x46, 0x3b, 0x51, 0x71, 0x1e, 0x24, 0x13, 0xa7, 0xaf, 0xae, 0x2f, 0xd3, 0x26, 0x97, 0x49,
+	0xa4, 0x30, 0x5f, 0x4d, 0x22, 0x13, 0x05, 0xe9, 0x0b, 0x86, 0xbe, 0x0c, 0x0b, 0xd8, 0xb6, 0xea,
+	0x4d, 0x55, 0xef, 0x38, 0x9a, 0x67, 0x58, 0xe6, 0x4a, 0xe6, 0x8e, 0x70, 0x3f, 0xad, 0xe4, 0x69,
+	0x6f, 0x85, 0x77, 0x4a, 0x7f, 0x94, 0x82, 0x7c, 0x84, 0x1d, 0xed, 0x42, 0xce, 0xec, 0xb4, 0x5a,
+	0x46, 0xc3, 0xe0, 0x56, 0x9f, 0x93, 0xbf, 0x32, 0x54, 0x00, 0xe2, 0xa9, 0xdd, 0x52, 0xf1, 0xc0,
+	0x67, 0x50, 0xfa, 0xbc, 0xe8, 0x11, 0xa4, 0x1a, 0x18, 0x73, 0x1d, 0xee, 0x0d, 0x85, 0x20, 0xcb,
+	0xa2, 0x5b, 0x2a, 0xee, 0x60, 0xac, 0x10, 0x7a, 0xf4, 0x2e, 0x2c, 0x59, 0x1d, 0xcf, 0xee, 0x78,
+	0x6a, 0x49, 0xad, 0x5b, 0xed, 0xb6, 0xe1, 0xb5, 0xb1, 0xe9, 0xad, 0xa4, 0x28, 0xcc, 0x4f, 0x87,
+	0x60, 0xa8, 0xab, 0x15, 0x3d, 0x26, 0xc1, 0x91, 0xa7, 0x79, 0xb8, 0x1c, 0x90, 0x2b, 0x37, 0x18,
+	0x46, 0xa9, 0xdf, 0x15, 0x02, 0x96, 0xc3, 0xc0, 0xe9, 0x89, 0x80, 0xe5, 0x10, 0xf0, 0x31, 0xcc,
+	0x71, 0x60, 0x5d, 0xf3, 0xb4, 0x95, 0x59, 0x0a, 0xf8, 0x70, 0xd4, 0xa4, 0x6d, 0x69, 0x5e, 0xbd,
+	0x49, 0x4c, 0x7f, 0x48, 0x79, 0x2b, 0x9a, 0xa7, 0x29, 0x60, 0x05, 0xbf, 0xa5, 0xff, 0x10, 0x21,
+	0xeb, 0x3b, 0x1b, 0x3a, 0x80, 0x79, 0xcf, 0xd1, 0x74, 0xc3, 0x3c, 0x55, 0x6d, 0xcd, 0x70, 0x92,
+	0xba, 0xfb, 0x31, 0xe3, 0xa9, 0x6a, 0x86, 0xa3, 0xcc, 0x79, 0xfd, 0x06, 0xfa, 0x1a, 0xe4, 0x74,
+	0xdc, 0xf2, 0x34, 0xb5, 0xa4, 0x1a, 0x7c, 0x86, 0x5e, 0x1e, 0x00, 0x23, 0x41, 0xa0, 0x5b, 0x2a,
+	0x6e, 0xb6, 0xad, 0x8e, 0xe9, 0x29, 0x19, 0x4a, 0x5e, 0xda, 0xef, 0x73, 0xca, 0xaa, 0xc1, 0x27,
+	0x25, 0x09, 0xa7, 0xbc, 0x8f, 0xaa, 0xb0, 0xd0, 0xc0, 0xf8, 0xa2, 0xe9, 0x07, 0xbd, 0x8b, 0xc5,
+	0x54, 0x6a, 0xa1, 0x96, 0x66, 0xd6, 0xc3, 0xc6, 0xcf, 0x37, 0x70, 0xa8, 0x89, 0xb6, 0x21, 0x63,
+	0x6b, 0xe7, 0x2d, 0x4b, 0xd3, 0x57, 0x66, 0x92, 0x19, 0x84, 0xae, 0x7e, 0xc6, 0xa2, 0xf8, 0xbc,
+	0xd2, 0x2f, 0xc1, 0x5c, 0xa8, 0x1f, 0xed, 0x02, 0x84, 0x64, 0x14, 0xc6, 0x73, 0x8f, 0x10, 0x2b,
+	0x5d, 0x82, 0x26, 0x25, 0xc7, 0xba, 0xea, 0x9e, 0x69, 0x36, 0xb5, 0xf4, 0xbc, 0x92, 0x0f, 0x7a,
+	0xc9, 0xb0, 0xd2, 0x7f, 0x89, 0x6c, 0x09, 0x56, 0x5b, 0x9a, 0x61, 0x7a, 0xb8, 0xe7, 0x7d, 0x2e,
+	0x66, 0xfb, 0x9b, 0x90, 0xab, 0x93, 0x98, 0xa2, 0x92, 0x18, 0x90, 0x4e, 0x1e, 0x03, 0xb2, 0x94,
+	0x6b, 0x07, 0x63, 0x54, 0x86, 0x3c, 0x43, 0xd0, 0x74, 0xdd, 0xc1, 0xae, 0xcb, 0xe7, 0x78, 0x6d,
+	0x00, 0x85, 0xee, 0x66, 0x44, 0x00, 0x46, 0xa5, 0xcc, 0x53, 0x26, 0xde, 0x22, 0xfb, 0x87, 0xe3,
+	0x62, 0xac, 0xd3, 0x55, 0x39, 0xaf, 0xb0, 0x86, 0xf4, 0x23, 0x81, 0xad, 0xad, 0x6a, 0x4b, 0x33,
+	0xd1, 0x31, 0x2c, 0x90, 0xc9, 0x51, 0x6d, 0xdf, 0xfe, 0xdc, 0xde, 0x89, 0xc2, 0x6e, 0x30, 0x69,
+	0x4a, 0xde, 0x8d, 0xcc, 0xe1, 0x5d, 0x98, 0x27, 0xde, 0x5e, 0x6b, 0x19, 0x26, 0x99, 0x07, 0x3e,
+	0xf5, 0x73, 0x0d, 0x8c, 0xb7, 0x78, 0x17, 0xba, 0x0f, 0x8b, 0x34, 0xdc, 0x07, 0x44, 0xaa, 0x43,
+	0x6d, 0x3c, 0xaf, 0x2c, 0xd0, 0x7e, 0x9f, 0x50, 0x89, 0xa1, 0x74, 0xa9, 0x4d, 0x07, 0x29, 0x8f,
+	0xa4, 0x7f, 0x12, 0x43, 0xf1, 0xfc, 0x05, 0xaa, 0x57, 0x80, 0xac, 0x6d, 0xb9, 0x06, 0xdd, 0x58,
+	0x44, 0xba, 0xb1, 0x04, 0xed, 0xc1, 0x78, 0x98, 0x9a, 0x4a, 0x3c, 0x8c, 0xd9, 0xd0, 0xd2, 0x31,
+	0x1b, 0x5a, 0xac, 0x51, 0x67, 0x12, 0x1b, 0x75, 0x36, 0xd6, 0xa8, 0xbf, 0x09, 0xcc, 0x5d, 0x4e,
+	0x0c, 0x7c, 0x86, 0x9e, 0x40, 0xa6, 0x6b, 0xb8, 0x46, 0xad, 0x85, 0x93, 0xee, 0xf2, 0x3e, 0x6b,
+	0xf1, 0x84, 0xf1, 0xed, 0x5d, 0x53, 0x7c, 0x08, 0xb4, 0x0f, 0xb3, 0x96, 0xad, 0x3d, 0xef, 0xf8,
+	0xfb, 0xe4, 0x7a, 0x62, 0xb0, 0x43, 0xca, 0xb6, 0x77, 0x4d, 0xe1, 0x00, 0x85, 0x1f, 0xa7, 0x21,
+	0xc3, 0x47, 0x40, 0x5f, 0x83, 0x34, 0x0d, 0x38, 0x4c, 0xc2, 0x2f, 0x25, 0x01, 0x55, 0x28, 0x47,
+	0x8c, 0xbb, 0xa4, 0xa6, 0xe0, 0x2e, 0x9b, 0xc0, 0xd6, 0xb5, 0xea, 0xf5, 0x78, 0x30, 0xf8, 0xa9,
+	0x01, 0x3c, 0x9e, 0x50, 0xb2, 0x30, 0x66, 0xba, 0x5a, 0x9d, 0xcc, 0xe6, 0xbe, 0xae, 0x64, 0x28,
+	0xdf, 0x71, 0x0f, 0x35, 0xe1, 0x56, 0x8d, 0xb8, 0x08, 0x8d, 0xa4, 0x6a, 0xd8, 0xc1, 0x96, 0x27,
+	0x77, 0xb0, 0xa5, 0xda, 0xc5, 0x4e, 0xf4, 0x14, 0xb2, 0x7e, 0x06, 0xb2, 0xb2, 0x46, 0xb1, 0xe5,
+	0xe1, 0x09, 0x50, 0x24, 0xed, 0x26, 0xa9, 0x90, 0xe5, 0x61, 0x32, 0x3f, 0x4a, 0x86, 0x67, 0x20,
+	0x21, 0x38, 0x79, 0xe5, 0xf6, 0x55, 0xe1, 0x64, 0xf4, 0x2d, 0x58, 0xa4, 0x3b, 0xa4, 0x5a, 0x52,
+	0xdb, 0xd8, 0xd3, 0xa8, 0x05, 0xee, 0x53, 0xd8, 0x3b, 0xc3, 0x36, 0xd2, 0xa7, 0x9c, 0x4e, 0x59,
+	0xa0, 0x5d, 0x25, 0xbf, 0xdd, 0xc7, 0x92, 0xfb, 0x58, 0x5f, 0x19, 0x0b, 0x4b, 0xf6, 0xdb, 0x85,
+	0x1f, 0xa6, 0x60, 0x96, 0xf9, 0xe4, 0x15, 0xbc, 0xef, 0x7f, 0x6f, 0x92, 0x77, 0x61, 0x21, 0x48,
+	0x33, 0xbb, 0x5a, 0xab, 0x83, 0xf9, 0x54, 0xdf, 0x1d, 0xa6, 0xf8, 0x09, 0x21, 0xa2, 0x53, 0x31,
+	0xcf, 0x67, 0x96, 0xf6, 0x84, 0x80, 0x64, 0x0e, 0x74, 0x7b, 0x4c, 0x20, 0x99, 0x01, 0xfd, 0x1f,
+	0x9d, 0xd8, 0xad, 0x39, 0xc8, 0xd1, 0xd9, 0xe8, 0x1a, 0xf8, 0x4c, 0xfa, 0xc7, 0x74, 0x68, 0x7f,
+	0xa1, 0xf1, 0xf0, 0xed, 0xc1, 0x78, 0xf8, 0x28, 0xf1, 0x71, 0x65, 0x58, 0x50, 0x3c, 0x18, 0x08,
+	0x8a, 0xaf, 0x8e, 0x87, 0x78, 0x21, 0x32, 0xfe, 0xa5, 0xd8, 0x8f, 0x8c, 0x7b, 0x00, 0x54, 0x1b,
+	0x1a, 0x56, 0x46, 0x9e, 0x6f, 0x06, 0xf1, 0x15, 0x6a, 0x0a, 0x76, 0xd8, 0x0b, 0x87, 0x09, 0x71,
+	0xba, 0x61, 0x22, 0x75, 0xf5, 0x30, 0xf1, 0x26, 0x64, 0xa8, 0x9e, 0x63, 0x07, 0xdc, 0x59, 0xc2,
+	0x76, 0xdc, 0x2b, 0x28, 0xc1, 0x72, 0x9e, 0x9a, 0xc9, 0xb6, 0x6e, 0xc0, 0xf5, 0x3e, 0x12, 0x73,
+	0xa8, 0x8f, 0x04, 0x98, 0x3b, 0x8e, 0xe4, 0xaa, 0x19, 0xbe, 0x0a, 0xf8, 0x48, 0xb7, 0x87, 0x39,
+	0xec, 0x26, 0xf9, 0x41, 0x04, 0x66, 0xbe, 0xdf, 0xe7, 0x94, 0xf9, 0x74, 0x24, 0xe4, 0x94, 0xa5,
+	0x5f, 0x81, 0xa5, 0x8a, 0xe1, 0xe0, 0xba, 0x87, 0xf5, 0xb0, 0x28, 0x8f, 0x60, 0xc6, 0xf5, 0x34,
+	0xc7, 0x4b, 0x2a, 0x08, 0xa3, 0x46, 0x25, 0x48, 0x61, 0x53, 0x4f, 0x2a, 0x03, 0xa1, 0x95, 0x3e,
+	0x49, 0xc3, 0x52, 0x4c, 0xe4, 0x42, 0x8f, 0x20, 0xc3, 0x13, 0x77, 0x2e, 0xc3, 0xe5, 0xc9, 0xf7,
+	0x2c, 0x4b, 0xdb, 0xfb, 0x6c, 0x72, 0xa2, 0x6c, 0x9f, 0xb1, 0xc9, 0xe8, 0x75, 0xc8, 0xb6, 0xb4,
+	0x76, 0x4d, 0x27, 0xc3, 0x25, 0xca, 0xf5, 0x19, 0x75, 0x29, 0xc4, 0x28, 0x73, 0x67, 0x4b, 0xc4,
+	0x28, 0xa3, 0x37, 0x00, 0x3a, 0x66, 0xc3, 0x68, 0xb5, 0xb0, 0xae, 0x96, 0x78, 0x7e, 0x7f, 0x39,
+	0x6b, 0xce, 0xa7, 0x2f, 0x45, 0x98, 0x65, 0x7e, 0xea, 0x4e, 0xc8, 0x2c, 0xa3, 0x5b, 0x30, 0xdb,
+	0xc4, 0xc6, 0x69, 0xd3, 0xe3, 0x65, 0x11, 0xde, 0xba, 0x70, 0xf4, 0xca, 0x5e, 0xf1, 0xe8, 0xf5,
+	0x1a, 0xdc, 0x64, 0x59, 0x2b, 0xf5, 0x0d, 0x02, 0xcb, 0x87, 0xcd, 0x91, 0x61, 0xb7, 0xc4, 0x15,
+	0x41, 0x59, 0xa2, 0x04, 0x47, 0xfc, 0xfb, 0x1e, 0x93, 0xa3, 0x08, 0x4b, 0x6e, 0xdd, 0x53, 0xfd,
+	0x9c, 0x5a, 0xb5, 0x1d, 0xdc, 0x30, 0x7a, 0x2b, 0x40, 0x85, 0xbd, 0xe1, 0xd6, 0xbd, 0x2a, 0xff,
+	0x52, 0xa5, 0x1f, 0xa4, 0x3f, 0x13, 0xe0, 0x3a, 0x17, 0x62, 0xa7, 0x63, 0xd2, 0xb5, 0x8c, 0xde,
+	0x86, 0x5c, 0x20, 0x28, 0xf7, 0x9f, 0x04, 0xfb, 0xa7, 0x83, 0x07, 0x70, 0x94, 0x3e, 0x0a, 0x7a,
+	0x13, 0xd2, 0xd4, 0x2c, 0xe2, 0xf8, 0x66, 0xa1, 0x8c, 0x64, 0xa9, 0xc5, 0x0c, 0x81, 0x16, 0x59,
+	0xad, 0x88, 0x08, 0x99, 0x67, 0x65, 0xa0, 0x57, 0x40, 0xb0, 0x13, 0x79, 0xaf, 0x60, 0x13, 0xda,
+	0xe7, 0x89, 0x3c, 0x56, 0x78, 0x2e, 0x35, 0x20, 0xab, 0x60, 0x17, 0x3b, 0x5d, 0xec, 0xa2, 0x9f,
+	0x05, 0xd1, 0x49, 0xb6, 0xb2, 0x44, 0xa7, 0x44, 0xa9, 0x93, 0x2d, 0x28, 0xd1, 0x91, 0xa5, 0xdf,
+	0x17, 0x21, 0xeb, 0xcf, 0x11, 0xda, 0x84, 0x94, 0xdd, 0x34, 0xf8, 0x48, 0xeb, 0x09, 0xad, 0x16,
+	0xd8, 0x9f, 0xf0, 0x92, 0x83, 0xac, 0x69, 0x99, 0x75, 0xcc, 0x0f, 0x92, 0xac, 0x81, 0xca, 0x34,
+	0x44, 0x79, 0x38, 0x69, 0x92, 0xee, 0x4b, 0x44, 0xcb, 0x16, 0x0a, 0xe3, 0x45, 0x15, 0xc8, 0x3a,
+	0xdc, 0x24, 0x49, 0xab, 0xa0, 0xbe, 0x09, 0x95, 0x80, 0x13, 0x49, 0xe4, 0xb8, 0x6e, 0xb9, 0x58,
+	0xb5, 0x4c, 0x95, 0xac, 0x32, 0xba, 0x9c, 0xb3, 0xca, 0x1c, 0xed, 0x3c, 0x34, 0x77, 0x8c, 0x56,
+	0x4b, 0x2a, 0x03, 0xf8, 0x12, 0xec, 0xeb, 0xf1, 0xb5, 0x5d, 0x74, 0x1b, 0xe6, 0xb4, 0x96, 0xa7,
+	0xd6, 0x70, 0xbd, 0xf9, 0x50, 0x6e, 0x53, 0x75, 0x73, 0x0a, 0x68, 0x2d, 0x6f, 0x8b, 0xf5, 0x48,
+	0x7f, 0x2b, 0x42, 0x3e, 0xa2, 0x07, 0x7a, 0xc7, 0xb7, 0x02, 0x01, 0x5a, 0x90, 0xdf, 0x1c, 0xcb,
+	0x0a, 0xd1, 0xd6, 0xb6, 0xd9, 0x69, 0xfb, 0x76, 0x29, 0x40, 0xd6, 0xc5, 0xcf, 0x3b, 0xd8, 0xb7,
+	0x7a, 0x5a, 0x09, 0xda, 0xd2, 0xf7, 0x04, 0xb8, 0x71, 0x81, 0x11, 0xdd, 0x83, 0xdb, 0xd5, 0xc3,
+	0xa3, 0xfd, 0xe3, 0xfd, 0xc3, 0x03, 0xf5, 0xe8, 0x78, 0xf3, 0x78, 0x5b, 0xdd, 0x3e, 0x78, 0xe7,
+	0xa9, 0xfa, 0xce, 0xc1, 0x51, 0x75, 0xbb, 0xbc, 0xbf, 0xb3, 0xbf, 0x5d, 0x59, 0xbc, 0x86, 0xd6,
+	0xa0, 0x10, 0x47, 0x74, 0x58, 0xdd, 0x3e, 0xd8, 0xae, 0x2c, 0x0a, 0xc3, 0xbe, 0x97, 0x9f, 0x1c,
+	0x1e, 0x6d, 0x57, 0x16, 0x45, 0x74, 0x17, 0x56, 0xe3, 0xbe, 0xbf, 0xbb, 0x7f, 0xbc, 0x57, 0x51,
+	0x36, 0xdf, 0x3d, 0x58, 0x4c, 0xa1, 0x7b, 0xf0, 0xc5, 0x78, 0x88, 0xcd, 0xfd, 0xa7, 0xdb, 0x95,
+	0xc5, 0x74, 0x41, 0xcc, 0x0a, 0xd2, 0xc7, 0x02, 0xcc, 0x3c, 0xb1, 0x0f, 0x1a, 0x1e, 0x7a, 0x0b,
+	0xe6, 0x82, 0x40, 0x63, 0xe8, 0xdc, 0x4d, 0x5f, 0x49, 0x6a, 0xc5, 0x7d, 0x5d, 0x01, 0xbb, 0x3f,
+	0xab, 0x81, 0x4b, 0x8a, 0x93, 0xbb, 0xa4, 0x74, 0x0c, 0xf3, 0x7e, 0xff, 0xa1, 0x8d, 0x4d, 0xe2,
+	0xa2, 0x41, 0xb9, 0x41, 0x48, 0xe6, 0xa2, 0x3e, 0x7f, 0xbf, 0x30, 0x21, 0x3d, 0xeb, 0x3b, 0x4e,
+	0x99, 0x78, 0xe5, 0x54, 0x15, 0x97, 0x7e, 0x24, 0xc0, 0xa2, 0xff, 0xe9, 0x5d, 0xc3, 0x6b, 0xea,
+	0x8e, 0x76, 0x36, 0x5d, 0xd3, 0xbe, 0x0f, 0x4b, 0xfe, 0x72, 0x0b, 0x97, 0x51, 0xc5, 0x71, 0xcb,
+	0xa8, 0xc8, 0x47, 0x09, 0xd5, 0x52, 0xc3, 0xce, 0x9e, 0x1a, 0x70, 0xf6, 0xbf, 0x16, 0x60, 0x29,
+	0x30, 0x27, 0x3e, 0xd3, 0x1c, 0x9d, 0x65, 0xc0, 0x53, 0x55, 0xee, 0x3d, 0x40, 0x0e, 0xc5, 0xbe,
+	0x9a, 0x6e, 0x37, 0x38, 0x48, 0xbf, 0x4b, 0xfa, 0x36, 0xaf, 0x89, 0x6d, 0xf7, 0x70, 0xbd, 0x43,
+	0xe3, 0xf1, 0x5b, 0x30, 0xeb, 0x39, 0x5a, 0x1d, 0xbb, 0x2b, 0xc2, 0x9d, 0x54, 0x92, 0x6d, 0x31,
+	0xc2, 0x4e, 0x02, 0x74, 0x1d, 0x2b, 0x1c, 0x02, 0x3d, 0x24, 0x61, 0xcc, 0xee, 0xf8, 0xb2, 0xae,
+	0x5e, 0x7a, 0xee, 0x53, 0x18, 0x2d, 0x7a, 0x04, 0xb3, 0x2c, 0x53, 0xe7, 0x91, 0x7b, 0x04, 0x17,
+	0x27, 0x2e, 0x3c, 0x86, 0x19, 0x3a, 0x38, 0x19, 0x94, 0x1d, 0x36, 0x99, 0x02, 0xa3, 0x06, 0xa5,
+	0xb4, 0xd2, 0x27, 0x22, 0x2c, 0x0f, 0x7a, 0x28, 0xad, 0x11, 0x86, 0x77, 0x00, 0x61, 0xe2, 0x1d,
+	0x60, 0xc0, 0x1d, 0xc4, 0x2b, 0xb9, 0x83, 0x9f, 0x69, 0xa4, 0x26, 0xcc, 0x34, 0x22, 0x0e, 0x9d,
+	0x8e, 0x3a, 0x34, 0x7a, 0x1d, 0x32, 0xdc, 0x4d, 0x56, 0x66, 0x92, 0xd8, 0xcf, 0xa7, 0x96, 0x54,
+	0x78, 0x29, 0x66, 0x21, 0x4c, 0xcf, 0x86, 0xd2, 0xaf, 0x09, 0x50, 0x88, 0xab, 0x61, 0x10, 0xc9,
+	0x5d, 0x2f, 0x94, 0xb6, 0x8a, 0x97, 0xa6, 0xad, 0xa9, 0xab, 0xa5, 0xad, 0x52, 0x03, 0xbe, 0x18,
+	0x2b, 0x85, 0x6b, 0x5b, 0xa6, 0x8b, 0xd1, 0x2e, 0xa4, 0x69, 0x49, 0x41, 0x98, 0xbc, 0x28, 0x43,
+	0x01, 0xa4, 0x6f, 0x0b, 0xb0, 0x1c, 0x59, 0x5b, 0xa3, 0x14, 0x3d, 0x89, 0x55, 0x74, 0xa4, 0x04,
+	0x31, 0xc7, 0xbb, 0xa8, 0xc2, 0x6d, 0xb8, 0x39, 0x20, 0x07, 0x57, 0xd5, 0xaf, 0x87, 0x62, 0xff,
+	0xcb, 0x38, 0xe5, 0xf3, 0x3e, 0x1c, 0xad, 0x87, 0x06, 0x4d, 0xe9, 0xab, 0xb0, 0xb4, 0xe9, 0xd4,
+	0x92, 0x6a, 0x4d, 0xbc, 0x62, 0x39, 0x4a, 0xff, 0x22, 0xa5, 0x1b, 0x2a, 0xc6, 0x5f, 0x08, 0x03,
+	0x56, 0x72, 0x7d, 0xc1, 0xef, 0xc2, 0x3c, 0x3d, 0xe0, 0xa8, 0x11, 0xbe, 0x39, 0xda, 0xc7, 0x4f,
+	0x34, 0xab, 0x00, 0xd8, 0xd4, 0x7d, 0x02, 0xb6, 0xc5, 0xe4, 0xb0, 0xa9, 0xef, 0xc5, 0x4f, 0x6c,
+	0x7a, 0x4a, 0x13, 0xfb, 0xaf, 0x02, 0xdc, 0x1a, 0x94, 0xf9, 0x27, 0x61, 0xbc, 0x17, 0xe6, 0xb9,
+	0xef, 0x45, 0x5d, 0x63, 0x7a, 0x53, 0x22, 0xfd, 0xba, 0x00, 0x37, 0x07, 0xa0, 0x7f, 0x22, 0x6e,
+	0xb7, 0x05, 0x5f, 0x78, 0x62, 0x3c, 0xef, 0x18, 0xba, 0xe1, 0x9d, 0xfb, 0xd1, 0x37, 0x50, 0xf3,
+	0xcb, 0xb0, 0x60, 0x98, 0xf5, 0x56, 0x47, 0xc7, 0x2a, 0x3d, 0x69, 0xe8, 0xd4, 0x73, 0xb2, 0x4a,
+	0x9e, 0xf7, 0xd2, 0x44, 0x4f, 0x97, 0xde, 0x87, 0x42, 0x1c, 0x06, 0xd7, 0xe7, 0x71, 0x24, 0x9e,
+	0x25, 0x4f, 0x2d, 0x59, 0x10, 0xfb, 0x10, 0x5e, 0xbe, 0x80, 0xbd, 0x75, 0xbe, 0xaf, 0xfb, 0x22,
+	0x4e, 0x73, 0x5f, 0x94, 0x7e, 0x1e, 0x56, 0x87, 0x0c, 0x36, 0x15, 0x5d, 0x5a, 0x31, 0xf0, 0xee,
+	0xa5, 0xca, 0xa4, 0xae, 0xa0, 0xcc, 0x07, 0xb0, 0x36, 0x6c, 0xb4, 0xa9, 0x68, 0xf3, 0x1d, 0x01,
+	0xee, 0xc4, 0x0d, 0x50, 0x75, 0x8c, 0x3a, 0xf6, 0x35, 0x1a, 0x5c, 0x98, 0xe2, 0x74, 0x16, 0x26,
+	0x39, 0xde, 0xb6, 0x8c, 0xb6, 0xe1, 0xd1, 0x83, 0x70, 0x5a, 0x61, 0x0d, 0xe9, 0x4f, 0x04, 0xb8,
+	0x7b, 0x89, 0x48, 0xd3, 0x50, 0x1b, 0x6d, 0x80, 0x38, 0x91, 0x9f, 0x89, 0x86, 0x2e, 0xa9, 0x90,
+	0x3f, 0xb2, 0x1d, 0xac, 0x05, 0x13, 0x7e, 0x10, 0x6b, 0x9e, 0xc9, 0x53, 0x8b, 0xbf, 0x13, 0x61,
+	0xc1, 0x1f, 0x81, 0x6b, 0xfb, 0x1e, 0x2c, 0xd7, 0xb0, 0xeb, 0xa9, 0x25, 0xd5, 0xb3, 0x54, 0x59,
+	0x9d, 0xf8, 0xa4, 0xb7, 0x48, 0x50, 0x4a, 0xc7, 0x96, 0x1c, 0x14, 0x5e, 0x7c, 0x64, 0x99, 0x20,
+	0x97, 0xd4, 0xc8, 0x95, 0xf5, 0xd8, 0xc8, 0xf2, 0xb1, 0x55, 0x0a, 0x90, 0xdf, 0x84, 0x55, 0xcd,
+	0xb6, 0x1d, 0xab, 0xa7, 0xe2, 0x46, 0x03, 0xd7, 0x3d, 0xa3, 0x8b, 0x55, 0x9b, 0xcc, 0x21, 0xd7,
+	0x82, 0x86, 0x53, 0x41, 0x59, 0x61, 0x44, 0xdb, 0x3e, 0x0d, 0x9d, 0x66, 0x22, 0xe2, 0x25, 0x00,
+	0x4c, 0x58, 0x1a, 0xc7, 0x86, 0x00, 0x10, 0x49, 0xa4, 0x1f, 0xa6, 0x60, 0xf9, 0xc8, 0x68, 0x77,
+	0x5a, 0x9a, 0x47, 0xeb, 0x69, 0x81, 0x43, 0x07, 0x07, 0x12, 0x61, 0x8c, 0x03, 0xc9, 0xeb, 0xc1,
+	0x81, 0x24, 0x69, 0xf1, 0x9c, 0x91, 0xa3, 0x13, 0xc8, 0x38, 0x56, 0xc7, 0x33, 0xcc, 0x53, 0xbe,
+	0xa5, 0x3d, 0x1e, 0xb9, 0x09, 0xc4, 0x08, 0x5d, 0x54, 0x18, 0x86, 0xe2, 0x83, 0x15, 0xfe, 0x5b,
+	0x80, 0x0c, 0xef, 0x44, 0xbf, 0x00, 0x19, 0x1d, 0x37, 0xb4, 0x4e, 0xcb, 0xd7, 0xa9, 0x72, 0x95,
+	0x31, 0x8a, 0x15, 0x86, 0xb5, 0x77, 0x4d, 0xf1, 0x61, 0xd1, 0x29, 0x80, 0x6b, 0x98, 0xa7, 0x2d,
+	0xac, 0x36, 0x2d, 0xbf, 0xee, 0xb8, 0x73, 0xa5, 0x41, 0x8e, 0x28, 0xdc, 0x9e, 0x65, 0xef, 0x5d,
+	0x53, 0x72, 0xae, 0xdf, 0x28, 0xcc, 0x41, 0x2e, 0xf8, 0x52, 0xc8, 0x41, 0x86, 0xcb, 0xb2, 0x95,
+	0x83, 0x8c, 0x8b, 0x3d, 0xc2, 0x29, 0x7d, 0x4c, 0xd2, 0xac, 0x28, 0x34, 0x5f, 0x28, 0xdb, 0xc1,
+	0x24, 0x4d, 0xb4, 0xdf, 0xfa, 0x53, 0xf6, 0x75, 0xc8, 0xfa, 0x95, 0xf0, 0x64, 0x87, 0xd6, 0x80,
+	0x5c, 0xfa, 0x53, 0x11, 0x72, 0xdb, 0x5d, 0x6c, 0x7a, 0xf4, 0xf9, 0xe5, 0xe7, 0xe3, 0x59, 0x1a,
+	0xbf, 0x93, 0x9a, 0xf8, 0x49, 0x20, 0xcd, 0x85, 0x42, 0xf5, 0x86, 0x7f, 0x11, 0x61, 0x21, 0xb0,
+	0x11, 0xab, 0x94, 0x4c, 0xdb, 0x50, 0x43, 0x1e, 0x49, 0x8a, 0x2f, 0xea, 0x91, 0x64, 0xea, 0xca,
+	0x8f, 0x24, 0x23, 0xcf, 0x4a, 0xd3, 0x93, 0x3f, 0x2b, 0x95, 0xfe, 0x41, 0x84, 0x1b, 0xd4, 0xba,
+	0x91, 0x02, 0xe1, 0x54, 0x4b, 0x51, 0x53, 0xde, 0xf2, 0xd0, 0x1b, 0x00, 0x41, 0xdd, 0x2e, 0xd9,
 	0xd5, 0x5a, 0xce, 0xa7, 0x2f, 0x45, 0x98, 0x93, 0x5d, 0xaf, 0x05, 0xcc, 0x32, 0xba, 0x0d, 0xbe,
-	0x20, 0xf4, 0x1d, 0xde, 0x34, 0xbd, 0x5f, 0x01, 0xde, 0xb5, 0x83, 0xb1, 0xa4, 0x01, 0x8a, 0x18,
-	0xf3, 0x39, 0xd4, 0x45, 0xeb, 0xf0, 0x02, 0x1d, 0xe2, 0xad, 0x36, 0x6e, 0xe3, 0xe7, 0x38, 0xce,
-	0x27, 0x22, 0xdc, 0x8a, 0xe8, 0xf2, 0x7c, 0x8a, 0xb0, 0x5f, 0x1c, 0xe7, 0x08, 0x57, 0xc8, 0xa6,
-	0xfb, 0x4a, 0xbe, 0xbf, 0x95, 0x86, 0xe5, 0x88, 0x31, 0xc3, 0xc5, 0xd3, 0x9f, 0x58, 0x33, 0xc6,
-	0x9a, 0x15, 0xb8, 0x61, 0x3b, 0xb8, 0xa3, 0x86, 0x86, 0x4f, 0x72, 0xa1, 0x9d, 0x27, 0x4c, 0x4a,
-	0x20, 0xc2, 0x25, 0x94, 0x64, 0x37, 0xdb, 0x11, 0x14, 0x19, 0x3d, 0x81, 0x4c, 0xcd, 0x62, 0xaf,
-	0xf7, 0x32, 0xe3, 0x9f, 0x66, 0x7c, 0x0c, 0xe9, 0x07, 0xfe, 0x86, 0x16, 0x14, 0xf2, 0xae, 0x78,
-	0xa8, 0x25, 0x4c, 0xf8, 0xa1, 0x96, 0x06, 0xcb, 0xd1, 0x5a, 0x83, 0x5a, 0x52, 0xeb, 0x96, 0x13,
-	0xbc, 0x6d, 0x18, 0x31, 0x07, 0x42, 0x91, 0x9a, 0x43, 0x69, 0xc7, 0x72, 0xe4, 0x98, 0x21, 0x64,
-	0x3a, 0x44, 0x69, 0x94, 0xb7, 0x8f, 0x83, 0x86, 0x90, 0x77, 0x2c, 0xa7, 0x24, 0x7d, 0x28, 0xf0,
-	0x5d, 0x2b, 0x5c, 0x50, 0x09, 0x55, 0x3c, 0x84, 0x48, 0xad, 0xe8, 0x72, 0x7d, 0x45, 0x9c, 0x40,
-	0xd1, 0xf1, 0xdf, 0x05, 0x58, 0xa3, 0x32, 0xd0, 0xa4, 0xae, 0x6c, 0x38, 0xb5, 0xb6, 0xe1, 0x6d,
-	0x39, 0x58, 0xfb, 0x00, 0x3b, 0x65, 0x07, 0xeb, 0x86, 0x87, 0x36, 0x20, 0xcb, 0xde, 0xd0, 0x04,
-	0x0b, 0x7b, 0xe8, 0x39, 0x80, 0x3d, 0xba, 0xd9, 0xd7, 0xd1, 0x2e, 0x2c, 0x10, 0x2f, 0x34, 0xac,
-	0xb6, 0xab, 0x9e, 0xb2, 0x7b, 0x99, 0x44, 0x39, 0xdc, 0x0d, 0x9f, 0x8b, 0x5f, 0xe6, 0xa0, 0x6f,
-	0xc1, 0xac, 0x89, 0xcf, 0x03, 0x8c, 0x24, 0x8b, 0x18, 0x4c, 0x7c, 0xce, 0xd9, 0xa5, 0xcf, 0x04,
-	0x58, 0x1d, 0xa4, 0x66, 0x05, 0x9f, 0x7e, 0x41, 0xb4, 0xfc, 0x44, 0x80, 0x7c, 0x05, 0x77, 0xab,
-	0x9a, 0xa3, 0xb5, 0xb0, 0x87, 0x1d, 0x17, 0xad, 0x02, 0x18, 0xae, 0x8a, 0x4d, 0xed, 0x94, 0xe4,
-	0xf5, 0x02, 0xad, 0x82, 0xe5, 0x0c, 0x77, 0x9b, 0x75, 0xa0, 0xef, 0xc0, 0x42, 0xdd, 0xe8, 0x62,
-	0x5d, 0xad, 0x69, 0xa6, 0x6e, 0xe8, 0x9a, 0x87, 0x5d, 0x5e, 0xbd, 0x19, 0xaa, 0xfc, 0x0d, 0xca,
-	0x58, 0x0e, 0xf8, 0xd0, 0x97, 0x20, 0xdb, 0xd2, 0xba, 0xe4, 0xa8, 0xe4, 0x52, 0xc1, 0xf3, 0x4a,
-	0xa6, 0xa5, 0x75, 0xf7, 0x2c, 0xdb, 0x45, 0x0f, 0x60, 0x99, 0x7c, 0xf2, 0x43, 0xbc, 0xab, 0xda,
-	0xd8, 0xe9, 0x55, 0x74, 0xf3, 0xca, 0x62, 0x4b, 0xeb, 0x06, 0x65, 0x8f, 0x2a, 0x76, 0x68, 0x4d,
-	0xe0, 0x7d, 0x98, 0xdf, 0xc5, 0x26, 0x76, 0x0d, 0xb7, 0x4c, 0x42, 0x8e, 0xe9, 0xa1, 0xc7, 0x00,
-	0x3a, 0xee, 0xaa, 0x36, 0x51, 0xcf, 0x4d, 0x7a, 0xda, 0x89, 0xd8, 0x43, 0xc9, 0xe9, 0xbc, 0xe9,
-	0x4a, 0x1f, 0x0b, 0x70, 0x83, 0x88, 0xdf, 0xc4, 0xae, 0x67, 0xd4, 0x3e, 0xa0, 0x71, 0x65, 0xd0,
-	0xda, 0x43, 0x90, 0xb6, 0x6c, 0xcc, 0x56, 0x9c, 0xa0, 0xd0, 0xdf, 0x68, 0x09, 0xa6, 0x69, 0x71,
-	0x91, 0x1f, 0xea, 0x59, 0x83, 0x50, 0x36, 0x8c, 0xb3, 0x06, 0x3f, 0xa8, 0xd3, 0xdf, 0x68, 0x01,
-	0x52, 0x4d, 0xeb, 0x9c, 0x46, 0x7e, 0x41, 0x21, 0x3f, 0xd1, 0x3d, 0xc8, 0xeb, 0x34, 0xb8, 0xaa,
-	0x1d, 0xab, 0xd9, 0x6e, 0x61, 0x1a, 0xcf, 0x05, 0x65, 0x8e, 0x75, 0x9e, 0xd0, 0x3e, 0x92, 0xa7,
-	0xb1, 0x37, 0x96, 0x8c, 0x24, 0x43, 0x49, 0xe8, 0xab, 0x3b, 0x46, 0x20, 0xfd, 0xb1, 0x00, 0xcb,
-	0x7d, 0x1a, 0xf8, 0xc7, 0xfd, 0x5d, 0x7e, 0x53, 0x26, 0x8c, 0x1f, 0xe9, 0xd9, 0x8d, 0x59, 0x50,
-	0xb0, 0x12, 0x43, 0x05, 0xab, 0x4b, 0x75, 0xe4, 0xd4, 0xa5, 0x3a, 0xb2, 0xf4, 0x3e, 0xbc, 0x70,
-	0x49, 0x36, 0x7e, 0x62, 0x2d, 0x07, 0x85, 0xac, 0x54, 0x92, 0xa7, 0x2f, 0xfd, 0x30, 0xac, 0x8c,
-	0x77, 0x06, 0x2f, 0xf6, 0x7d, 0x38, 0xf2, 0x1c, 0xac, 0xb5, 0x26, 0x6d, 0x01, 0x49, 0x87, 0xd5,
-	0x01, 0x03, 0x5d, 0x52, 0x47, 0x18, 0x5b, 0x1d, 0xf9, 0xb7, 0xf3, 0x30, 0xf7, 0x56, 0x1b, 0x3b,
-	0x17, 0x47, 0xd8, 0xe9, 0x18, 0x35, 0x8c, 0x7e, 0x57, 0x88, 0x7f, 0xfe, 0xb7, 0x31, 0xce, 0x26,
-	0xca, 0x6c, 0x52, 0x78, 0x7d, 0x2c, 0x5e, 0xae, 0xe6, 0x2f, 0xf6, 0x5f, 0x98, 0xbf, 0x32, 0xda,
-	0xc6, 0xc3, 0x65, 0x78, 0x38, 0x22, 0x17, 0x1f, 0xfd, 0x02, 0xe6, 0x22, 0xbb, 0xe4, 0xd0, 0x09,
-	0x8d, 0xb9, 0x4a, 0x2b, 0xbc, 0x32, 0x1a, 0x13, 0x1f, 0xfa, 0x43, 0x01, 0xe6, 0xa3, 0xb7, 0x45,
-	0x68, 0x34, 0x25, 0xfc, 0x7b, 0x89, 0xc2, 0xab, 0xa3, 0xb2, 0x31, 0x09, 0x5e, 0x16, 0xd0, 0x2f,
-	0x43, 0x3e, 0x72, 0xeb, 0x82, 0x46, 0x52, 0xc5, 0x4d, 0x6c, 0xfc, 0xd8, 0xab, 0x9d, 0x97, 0x05,
-	0xf4, 0x3b, 0x02, 0xa0, 0xcb, 0x15, 0x6a, 0xf4, 0xcd, 0x61, 0x78, 0x03, 0xef, 0x68, 0x0a, 0x1b,
-	0xe3, 0xb0, 0x06, 0xf2, 0xfc, 0x81, 0x00, 0xb7, 0x62, 0xaf, 0x3c, 0xd0, 0xa3, 0x91, 0x71, 0x43,
-	0x37, 0x19, 0x85, 0x6f, 0x8d, 0xc9, 0xcd, 0x5d, 0xe5, 0x23, 0x01, 0x96, 0xe3, 0x2f, 0x2f, 0xd0,
-	0xe8, 0xc8, 0xe1, 0x2b, 0x96, 0xc2, 0xcf, 0x8d, 0xcb, 0x1e, 0x98, 0xec, 0xfb, 0x42, 0xdc, 0x95,
-	0x19, 0xbf, 0x64, 0x40, 0xdf, 0x1e, 0x07, 0x3f, 0x7c, 0x65, 0x52, 0xd8, 0xbc, 0x06, 0x42, 0x20,
-	0xe4, 0x19, 0xcc, 0xb0, 0x7b, 0x00, 0x34, 0x3c, 0xad, 0x0d, 0xdf, 0x48, 0x14, 0x8a, 0x49, 0xc9,
-	0xf9, 0x4c, 0xfd, 0x6a, 0xcc, 0xee, 0xff, 0xea, 0xa8, 0xa1, 0x9b, 0x8f, 0xfd, 0xda, 0xc8, 0x7c,
-	0x5c, 0x88, 0x3f, 0x14, 0xe0, 0x56, 0xec, 0xde, 0x32, 0xdc, 0x8b, 0xaf, 0xda, 0xfb, 0x86, 0x7b,
-	0xf1, 0x95, 0x1b, 0xda, 0xcb, 0x82, 0xfc, 0x7b, 0x02, 0xdc, 0xe4, 0xd5, 0x66, 0xc3, 0x32, 0xfd,
-	0x2d, 0x89, 0xec, 0x00, 0xe1, 0x12, 0x74, 0x82, 0x1d, 0x20, 0xa6, 0x18, 0x9e, 0x60, 0x07, 0x88,
-	0xab, 0x73, 0x6f, 0xfd, 0x95, 0xf8, 0xf7, 0x9f, 0xae, 0x09, 0x3f, 0xfc, 0x74, 0x4d, 0xf8, 0xb7,
-	0x4f, 0xd7, 0x84, 0xef, 0x7d, 0xb6, 0x36, 0xf5, 0xc3, 0xcf, 0xd6, 0xa6, 0xfe, 0xf9, 0xb3, 0xb5,
-	0x29, 0x90, 0x6a, 0x56, 0x6b, 0x08, 0xe8, 0x56, 0x96, 0x24, 0x82, 0x8e, 0xe5, 0x59, 0x55, 0xe1,
-	0xbd, 0xea, 0x99, 0xe1, 0x35, 0xda, 0xa7, 0x84, 0x68, 0xbd, 0x66, 0xb9, 0x2d, 0xcb, 0x5d, 0x77,
-	0x70, 0x53, 0xbb, 0xc0, 0xce, 0x7a, 0x47, 0x0e, 0x7e, 0xd6, 0x1a, 0x9a, 0x61, 0xba, 0xeb, 0x57,
-	0xff, 0xbd, 0x88, 0xd7, 0x75, 0xdc, 0xed, 0x94, 0xbe, 0x2f, 0xa6, 0xab, 0xe5, 0x72, 0xe5, 0xcf,
-	0xc5, 0xb5, 0xaa, 0x2f, 0x45, 0x99, 0x48, 0x51, 0x0e, 0xa4, 0xa8, 0xe0, 0x6e, 0xf1, 0xa4, 0xf4,
-	0x49, 0x8f, 0xe0, 0x29, 0x21, 0x78, 0x1a, 0x10, 0x3c, 0xad, 0xe0, 0xee, 0xd3, 0x93, 0xd2, 0xa7,
-	0xe2, 0x4b, 0x57, 0x13, 0x3c, 0xdd, 0xad, 0x6e, 0xf9, 0xff, 0x17, 0xce, 0x7f, 0x8a, 0x92, 0x4f,
-	0xbc, 0xb1, 0x41, 0xa8, 0xc9, 0x7f, 0x39, 0xf9, 0xc6, 0x46, 0x05, 0x77, 0x37, 0x36, 0x4e, 0x4a,
-	0xa7, 0x33, 0xf4, 0xaf, 0x2d, 0x3c, 0xf8, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x53, 0xbb, 0xeb,
-	0x2e, 0xf9, 0x42, 0x00, 0x00,
+	0x20, 0xf4, 0x1d, 0xde, 0x0c, 0xbd, 0x5f, 0x01, 0xde, 0xb5, 0x83, 0xb1, 0xa4, 0x01, 0x8a, 0x18,
+	0xf3, 0x05, 0xd4, 0x45, 0x1b, 0xf0, 0x12, 0x1d, 0xe2, 0xed, 0x0e, 0xee, 0xe0, 0x17, 0x38, 0xce,
+	0xf7, 0x45, 0xb8, 0x19, 0xd1, 0xe5, 0xc5, 0x14, 0x61, 0x3f, 0x3f, 0xce, 0x11, 0xae, 0x90, 0xcd,
+	0x0c, 0x94, 0x7c, 0x7f, 0x2b, 0x0d, 0xb7, 0x22, 0xc6, 0x0c, 0x17, 0x4f, 0xff, 0xdf, 0x9a, 0x31,
+	0xd6, 0xac, 0xc0, 0x75, 0xdb, 0xc1, 0x5d, 0x35, 0x34, 0x7c, 0x92, 0x0b, 0xed, 0x3c, 0x61, 0x52,
+	0x02, 0x11, 0x2e, 0xa0, 0x24, 0xbb, 0xd9, 0x8e, 0xa0, 0xc8, 0xe8, 0x29, 0x64, 0xea, 0x16, 0x7b,
+	0xbd, 0x97, 0x99, 0xfc, 0x34, 0xe3, 0x63, 0x48, 0xdf, 0xf3, 0x37, 0xb4, 0xa0, 0x90, 0x77, 0xc9,
+	0x43, 0x2d, 0x61, 0xca, 0x0f, 0xb5, 0x34, 0xb8, 0x15, 0xad, 0x35, 0xa8, 0x25, 0xb5, 0x61, 0x39,
+	0xc1, 0xdb, 0x86, 0x31, 0x73, 0x20, 0x14, 0xa9, 0x39, 0x94, 0x76, 0x2c, 0x47, 0x8e, 0x19, 0x42,
+	0xa6, 0x43, 0x94, 0xc6, 0x79, 0xfb, 0x38, 0x6c, 0x08, 0x79, 0xc7, 0x72, 0x4a, 0xd2, 0x47, 0x02,
+	0xdf, 0xb5, 0xc2, 0x05, 0x95, 0x50, 0xc5, 0x43, 0x88, 0xd4, 0x8a, 0x2e, 0xd6, 0x57, 0xc4, 0x29,
+	0x14, 0x1d, 0xff, 0x5d, 0x80, 0x35, 0x2a, 0x03, 0x4d, 0xea, 0xca, 0x86, 0x53, 0xef, 0x18, 0xde,
+	0x96, 0x83, 0xb5, 0x0f, 0xb1, 0x53, 0x76, 0xb0, 0x6e, 0x78, 0x68, 0x03, 0xb2, 0xec, 0x0d, 0x4d,
+	0xb0, 0xb0, 0x47, 0x9e, 0x03, 0xd8, 0xa3, 0x9b, 0x7d, 0x1d, 0xed, 0xc2, 0x22, 0xf1, 0x42, 0xc3,
+	0xea, 0xb8, 0x6a, 0x8d, 0xdd, 0xcb, 0x24, 0xca, 0xe1, 0xae, 0xfb, 0x5c, 0xfc, 0x32, 0x07, 0x7d,
+	0x03, 0xe6, 0x4c, 0x7c, 0x16, 0x60, 0x24, 0x59, 0xc4, 0x60, 0xe2, 0x33, 0xce, 0x2e, 0x7d, 0x26,
+	0xc0, 0xea, 0x30, 0x35, 0x2b, 0xb8, 0xf6, 0x39, 0xd1, 0xf2, 0xc7, 0x02, 0xe4, 0x2b, 0xb8, 0x57,
+	0xd5, 0x1c, 0xad, 0x8d, 0x3d, 0xec, 0xb8, 0x68, 0x15, 0xc0, 0x70, 0x55, 0x6c, 0x6a, 0x35, 0x92,
+	0xd7, 0x0b, 0xb4, 0x0a, 0x96, 0x33, 0xdc, 0x6d, 0xd6, 0x81, 0xbe, 0x05, 0x8b, 0x0d, 0xa3, 0x87,
+	0x75, 0xb5, 0xae, 0x99, 0xba, 0xa1, 0x6b, 0x1e, 0x76, 0x79, 0xf5, 0x66, 0xa4, 0xf2, 0xd7, 0x29,
+	0x63, 0x39, 0xe0, 0x43, 0x5f, 0x80, 0x6c, 0x5b, 0xeb, 0x91, 0xa3, 0x92, 0x4b, 0x05, 0xcf, 0x2b,
+	0x99, 0xb6, 0xd6, 0xdb, 0xb3, 0x6c, 0x17, 0x3d, 0x84, 0x5b, 0xe4, 0x93, 0x1f, 0xe2, 0x5d, 0xd5,
+	0xc6, 0x4e, 0xbf, 0xa2, 0x9b, 0x57, 0x96, 0xda, 0x5a, 0x2f, 0x28, 0x7b, 0x54, 0xb1, 0x43, 0xa3,
+	0xf6, 0x03, 0x58, 0x26, 0x4c, 0xfd, 0xf5, 0x57, 0xeb, 0xe8, 0xa7, 0xd8, 0xe3, 0xf9, 0x0a, 0x6a,
+	0x6b, 0xbd, 0xc0, 0x8b, 0xb7, 0xe8, 0x17, 0xe9, 0x03, 0x58, 0xd8, 0xc5, 0x26, 0x76, 0x0d, 0xb7,
+	0x4c, 0x82, 0x94, 0xe9, 0xa1, 0x27, 0x00, 0x3a, 0xee, 0xa9, 0x36, 0x31, 0x88, 0x9b, 0xf4, 0x7c,
+	0x14, 0xb1, 0xa0, 0x92, 0xd3, 0x79, 0xd3, 0x95, 0x3e, 0x11, 0xe0, 0x3a, 0x51, 0xb8, 0x85, 0x5d,
+	0xcf, 0xa8, 0x7f, 0x48, 0x23, 0xd1, 0xb0, 0xd5, 0x8a, 0x20, 0x6d, 0xd9, 0x98, 0xad, 0x51, 0x41,
+	0xa1, 0xbf, 0xd1, 0x32, 0xcc, 0xd0, 0x72, 0x24, 0x2f, 0x03, 0xb0, 0x06, 0xa1, 0x6c, 0x1a, 0xa7,
+	0x4d, 0x7e, 0xb4, 0xa7, 0xbf, 0xd1, 0x22, 0xa4, 0x5a, 0xd6, 0x19, 0x55, 0x55, 0x50, 0xc8, 0x4f,
+	0x74, 0x0f, 0xf2, 0x3a, 0x0d, 0xc7, 0x6a, 0xd7, 0x6a, 0x75, 0xda, 0x98, 0xee, 0x00, 0x82, 0x32,
+	0xcf, 0x3a, 0x4f, 0x68, 0x1f, 0xc9, 0xec, 0xd8, 0xab, 0x4c, 0x46, 0x92, 0xa1, 0x24, 0xf4, 0x9d,
+	0x1e, 0x23, 0x90, 0xfe, 0x58, 0x80, 0x5b, 0x03, 0x1a, 0xf8, 0x05, 0x82, 0x5d, 0x7e, 0xb7, 0x26,
+	0x4c, 0xbe, 0x37, 0xb0, 0x3b, 0xb6, 0xa0, 0xc4, 0x25, 0x86, 0x4a, 0x5c, 0x17, 0x2a, 0xcf, 0xa9,
+	0x0b, 0x95, 0x67, 0xe9, 0x03, 0x78, 0xe9, 0x82, 0x6c, 0xfc, 0x8c, 0x5b, 0x0e, 0x4a, 0x5f, 0xa9,
+	0x24, 0x8f, 0x65, 0x06, 0x61, 0x58, 0xe1, 0xef, 0x14, 0x5e, 0x1e, 0xf8, 0x70, 0xe4, 0x39, 0x58,
+	0x6b, 0x4f, 0xdb, 0x02, 0x92, 0x0e, 0xab, 0x43, 0x06, 0xba, 0xa0, 0x8e, 0x30, 0xb1, 0x3a, 0xf2,
+	0x6f, 0xe7, 0x61, 0xfe, 0xed, 0x0e, 0x76, 0xce, 0x8f, 0xb0, 0xd3, 0x35, 0xea, 0x18, 0xfd, 0xae,
+	0x10, 0xff, 0x60, 0x70, 0x63, 0x92, 0x6d, 0x97, 0xd9, 0xa4, 0xf0, 0xc6, 0x44, 0xbc, 0x5c, 0xcd,
+	0x5f, 0x1c, 0xbc, 0x62, 0x7f, 0x75, 0xbc, 0xad, 0x8a, 0xcb, 0xf0, 0x68, 0x4c, 0x2e, 0x3e, 0xfa,
+	0x39, 0xcc, 0x47, 0xf6, 0xd5, 0x91, 0x13, 0x1a, 0x73, 0xf9, 0x56, 0x78, 0x75, 0x3c, 0x26, 0x3e,
+	0xf4, 0x47, 0x02, 0x2c, 0x44, 0xef, 0x97, 0xd0, 0x78, 0x4a, 0xf8, 0x37, 0x19, 0x85, 0xd7, 0xc6,
+	0x65, 0x63, 0x12, 0x3c, 0x10, 0xd0, 0x2f, 0x43, 0x3e, 0x72, 0x4f, 0x83, 0xc6, 0x52, 0xc5, 0x4d,
+	0x6c, 0xfc, 0xd8, 0xcb, 0xa0, 0x07, 0x02, 0xfa, 0x1d, 0x01, 0xd0, 0xc5, 0x9a, 0x36, 0xfa, 0xfa,
+	0x28, 0xbc, 0xa1, 0xb7, 0x3a, 0x85, 0x8d, 0x49, 0x58, 0x03, 0x79, 0xfe, 0x40, 0x80, 0x9b, 0xb1,
+	0x97, 0x24, 0xe8, 0xf1, 0xd8, 0xb8, 0xa1, 0xbb, 0x8f, 0xc2, 0x37, 0x26, 0xe4, 0xe6, 0xae, 0xf2,
+	0xb1, 0x00, 0xb7, 0xe2, 0xaf, 0x3b, 0xd0, 0xf8, 0xc8, 0xe1, 0x4b, 0x99, 0xc2, 0xcf, 0x4d, 0xca,
+	0x1e, 0x98, 0xec, 0xbb, 0x42, 0xdc, 0x25, 0x1b, 0xbf, 0x96, 0x40, 0xdf, 0x9c, 0x04, 0x3f, 0x7c,
+	0xc9, 0x52, 0xd8, 0xbc, 0x02, 0x42, 0x20, 0xe4, 0x29, 0xcc, 0xb2, 0x9b, 0x03, 0x34, 0x3a, 0x11,
+	0x0e, 0xdf, 0x61, 0x14, 0x8a, 0x49, 0xc9, 0xf9, 0x4c, 0xfd, 0x6a, 0xcc, 0xee, 0xff, 0xda, 0xb8,
+	0xa1, 0x9b, 0x8f, 0xfd, 0xfa, 0xd8, 0x7c, 0x5c, 0x88, 0x3f, 0x14, 0xe0, 0x66, 0xec, 0xde, 0x32,
+	0xda, 0x8b, 0x2f, 0xdb, 0xfb, 0x46, 0x7b, 0xf1, 0xa5, 0x1b, 0xda, 0x03, 0x41, 0xfe, 0x3d, 0x01,
+	0x6e, 0xf0, 0xfa, 0xb4, 0x61, 0x99, 0xfe, 0x96, 0x44, 0x76, 0x80, 0x70, 0xd1, 0x3a, 0xc1, 0x0e,
+	0x10, 0x53, 0x3e, 0x4f, 0xb0, 0x03, 0xc4, 0x55, 0xc6, 0xb7, 0xfe, 0x4a, 0xfc, 0xfb, 0x4f, 0xd7,
+	0x84, 0x1f, 0x7c, 0xba, 0x26, 0xfc, 0xdb, 0xa7, 0x6b, 0xc2, 0x77, 0x3e, 0x5b, 0xbb, 0xf6, 0x83,
+	0xcf, 0xd6, 0xae, 0xfd, 0xf3, 0x67, 0x6b, 0xd7, 0x40, 0xaa, 0x5b, 0xed, 0x11, 0xa0, 0x5b, 0x59,
+	0x92, 0x08, 0x3a, 0x96, 0x67, 0x55, 0x85, 0xf7, 0xab, 0xa7, 0x86, 0xd7, 0xec, 0xd4, 0x08, 0xd1,
+	0x7a, 0xdd, 0x72, 0xdb, 0x96, 0xbb, 0xee, 0xe0, 0x96, 0x76, 0x8e, 0x9d, 0xf5, 0xae, 0x1c, 0xfc,
+	0xac, 0x37, 0x35, 0xc3, 0x74, 0xd7, 0x2f, 0xff, 0x0b, 0x13, 0x6f, 0xe8, 0xb8, 0xd7, 0x2d, 0x7d,
+	0x57, 0x4c, 0x57, 0xcb, 0xe5, 0xca, 0x9f, 0x8b, 0x6b, 0x55, 0x5f, 0x8a, 0x32, 0x91, 0xa2, 0x1c,
+	0x48, 0x51, 0xc1, 0xbd, 0xe2, 0x49, 0xe9, 0xfb, 0x7d, 0x82, 0x67, 0x84, 0xe0, 0x59, 0x40, 0xf0,
+	0xac, 0x82, 0x7b, 0xcf, 0x4e, 0x4a, 0x9f, 0x8a, 0xaf, 0x5c, 0x4e, 0xf0, 0x6c, 0xb7, 0xba, 0xe5,
+	0xff, 0x7f, 0x3b, 0xff, 0x29, 0x4a, 0x3e, 0xf1, 0xc6, 0x06, 0xa1, 0x26, 0xff, 0xe5, 0xe4, 0x1b,
+	0x1b, 0x15, 0xdc, 0xdb, 0xd8, 0x38, 0x29, 0xd5, 0x66, 0xe9, 0xdf, 0x67, 0x78, 0xf8, 0x3f, 0x01,
+	0x00, 0x00, 0xff, 0xff, 0xa5, 0xa6, 0x63, 0x50, 0x2b, 0x43, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -9667,6 +9678,11 @@ func (m *DexParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
+	if m.MaxExecutionBudget != 0 {
+		i = encodeVarintDex(dAtA, i, uint64(m.MaxExecutionBudget))
+		i--
+		dAtA[i] = 0x28
+	}
 	if m.MaxPositionsPerPair != 0 {
 		i = encodeVarintDex(dAtA, i, uint64(m.MaxPositionsPerPair))
 		i--
@@ -11397,6 +11413,9 @@ func (m *DexParameters) Size() (n int) {
 	if m.MaxPositionsPerPair != 0 {
 		n += 1 + sovDex(uint64(m.MaxPositionsPerPair))
 	}
+	if m.MaxExecutionBudget != 0 {
+		n += 1 + sovDex(uint64(m.MaxExecutionBudget))
+	}
 	return n
 }
 
@@ -21279,6 +21298,25 @@ func (m *DexParameters) Unmarshal(dAtA []byte) error {
 					break
 				}
 			}
+		case 5:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MaxExecutionBudget", wireType)
+			}
+			m.MaxExecutionBudget = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowDex
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.MaxExecutionBudget |= uint32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipDex(dAtA[iNdEx:])
diff --git a/relayer/chains/penumbra/core/component/funding/v1/funding.pb.go b/relayer/chains/penumbra/core/component/funding/v1/funding.pb.go
index aac8c97fb..234ccee8d 100644
--- a/relayer/chains/penumbra/core/component/funding/v1/funding.pb.go
+++ b/relayer/chains/penumbra/core/component/funding/v1/funding.pb.go
@@ -6,6 +6,7 @@ package fundingv1
 import (
 	fmt "fmt"
 	proto "github.com/cosmos/gogoproto/proto"
+	v1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/num/v1"
 	io "io"
 	math "math"
 	math_bits "math/bits"
@@ -104,9 +105,77 @@ func (m *GenesisContent) GetFundingParams() *FundingParameters {
 	return nil
 }
 
+// Indicates that a funding stream reward was paid.
+type EventFundingStreamReward struct {
+	// The recipient of the funding stream reward.
+	// This is a string value for future extensibility.
+	// Currently it will be either "community-pool"
+	// or an address.
+	Recipient string `protobuf:"bytes,1,opt,name=recipient,proto3" json:"recipient,omitempty"`
+	// The epoch for which the reward was paid.
+	EpochIndex uint64 `protobuf:"varint,2,opt,name=epoch_index,json=epochIndex,proto3" json:"epoch_index,omitempty"`
+	// The amount of the reward, in staking tokens.
+	RewardAmount *v1.Amount `protobuf:"bytes,3,opt,name=reward_amount,json=rewardAmount,proto3" json:"reward_amount,omitempty"`
+}
+
+func (m *EventFundingStreamReward) Reset()         { *m = EventFundingStreamReward{} }
+func (m *EventFundingStreamReward) String() string { return proto.CompactTextString(m) }
+func (*EventFundingStreamReward) ProtoMessage()    {}
+func (*EventFundingStreamReward) Descriptor() ([]byte, []int) {
+	return fileDescriptor_586f7399b4e8a469, []int{2}
+}
+func (m *EventFundingStreamReward) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *EventFundingStreamReward) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_EventFundingStreamReward.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 *EventFundingStreamReward) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_EventFundingStreamReward.Merge(m, src)
+}
+func (m *EventFundingStreamReward) XXX_Size() int {
+	return m.Size()
+}
+func (m *EventFundingStreamReward) XXX_DiscardUnknown() {
+	xxx_messageInfo_EventFundingStreamReward.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EventFundingStreamReward proto.InternalMessageInfo
+
+func (m *EventFundingStreamReward) GetRecipient() string {
+	if m != nil {
+		return m.Recipient
+	}
+	return ""
+}
+
+func (m *EventFundingStreamReward) GetEpochIndex() uint64 {
+	if m != nil {
+		return m.EpochIndex
+	}
+	return 0
+}
+
+func (m *EventFundingStreamReward) GetRewardAmount() *v1.Amount {
+	if m != nil {
+		return m.RewardAmount
+	}
+	return nil
+}
+
 func init() {
 	proto.RegisterType((*FundingParameters)(nil), "penumbra.core.component.funding.v1.FundingParameters")
 	proto.RegisterType((*GenesisContent)(nil), "penumbra.core.component.funding.v1.GenesisContent")
+	proto.RegisterType((*EventFundingStreamReward)(nil), "penumbra.core.component.funding.v1.EventFundingStreamReward")
 }
 
 func init() {
@@ -114,27 +183,34 @@ func init() {
 }
 
 var fileDescriptor_586f7399b4e8a469 = []byte{
-	// 320 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0xb1, 0x4a, 0x3b, 0x31,
-	0x1c, 0xc7, 0x9b, 0xe3, 0xcf, 0x7f, 0x38, 0xb5, 0x60, 0x5d, 0x9c, 0x82, 0xdc, 0x50, 0x9c, 0x12,
-	0x53, 0x71, 0x89, 0x5b, 0x0f, 0xda, 0x49, 0x38, 0x1c, 0x8a, 0x48, 0x40, 0xd2, 0x6b, 0xda, 0x1e,
-	0x78, 0xc9, 0x91, 0xa4, 0x07, 0xbe, 0x85, 0xcf, 0xe0, 0xe8, 0x93, 0x88, 0x53, 0x17, 0xc1, 0x51,
-	0xae, 0x9b, 0x4f, 0x21, 0xd1, 0xe4, 0x14, 0x1c, 0xea, 0x12, 0x7e, 0x09, 0x9f, 0x0f, 0xdf, 0x6f,
-	0x42, 0xe2, 0x93, 0x4a, 0xc8, 0x55, 0x39, 0xd5, 0x1c, 0xe7, 0x4a, 0x0b, 0x9c, 0xab, 0xb2, 0x52,
-	0x52, 0x48, 0x8b, 0xe7, 0x2b, 0x39, 0x2b, 0xe4, 0x02, 0xd7, 0x24, 0x8c, 0xa8, 0xd2, 0xca, 0xaa,
-	0x5e, 0x12, 0x0c, 0xe4, 0x0c, 0xd4, 0x1a, 0x28, 0x60, 0x35, 0x49, 0x0e, 0xe2, 0xfd, 0xd1, 0xd7,
-	0x2e, 0xe3, 0x9a, 0x97, 0xc2, 0x0a, 0x6d, 0x12, 0x19, 0x77, 0xc7, 0x42, 0x0a, 0x53, 0x98, 0x54,
-	0x49, 0x2b, 0xa4, 0xed, 0xb1, 0xb8, 0xeb, 0xa5, 0x9b, 0xca, 0x71, 0xe6, 0x10, 0x1c, 0x81, 0xe3,
-	0x9d, 0xc1, 0x19, 0xda, 0x9e, 0x81, 0x7e, 0x05, 0x5c, 0xee, 0xcd, 0x7f, 0x1c, 0x99, 0xe1, 0x4b,
-	0xf4, 0xd4, 0x40, 0xb0, 0x6e, 0x20, 0x78, 0x6b, 0x20, 0xb8, 0xdf, 0xc0, 0xce, 0x7a, 0x03, 0x3b,
-	0xaf, 0x1b, 0xd8, 0x89, 0xfb, 0xb9, 0x2a, 0xff, 0x90, 0x31, 0xdc, 0x0d, 0x21, 0xee, 0xe6, 0x19,
-	0xb8, 0xbe, 0x5a, 0x14, 0x76, 0xb9, 0x9a, 0x3a, 0x18, 0xe7, 0xca, 0x94, 0xca, 0x60, 0x2d, 0x6e,
-	0xf9, 0x9d, 0xd0, 0xb8, 0x1e, 0xb4, 0x63, 0xbe, 0xe4, 0x85, 0x34, 0x78, 0xfb, 0xcb, 0x9e, 0xfb,
-	0xb1, 0x26, 0x0f, 0xd1, 0xbf, 0x2c, 0x4d, 0x47, 0x8f, 0x51, 0x92, 0x85, 0x56, 0xa9, 0x6b, 0x95,
-	0xb6, 0xad, 0x7c, 0x13, 0x34, 0x21, 0xcf, 0xdf, 0x10, 0x73, 0x10, 0x6b, 0x21, 0xe6, 0x21, 0x36,
-	0x21, 0x4d, 0x84, 0xb6, 0x43, 0x6c, 0x9c, 0x0d, 0x2f, 0x84, 0xe5, 0x33, 0x6e, 0xf9, 0x7b, 0xd4,
-	0x0f, 0x02, 0xa5, 0xce, 0x70, 0xab, 0x57, 0x28, 0xf5, 0x0e, 0xa5, 0x13, 0x32, 0xfd, 0xff, 0xf9,
-	0x0f, 0x4e, 0x3f, 0x02, 0x00, 0x00, 0xff, 0xff, 0x6d, 0x01, 0xe0, 0xb6, 0x3b, 0x02, 0x00, 0x00,
+	// 430 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0xcd, 0x8a, 0xd4, 0x40,
+	0x14, 0x85, 0xbb, 0xe2, 0x20, 0x4c, 0xcd, 0x0f, 0x18, 0x37, 0x8d, 0x0c, 0x71, 0xc8, 0x62, 0x98,
+	0x55, 0x95, 0x19, 0x71, 0x13, 0x57, 0xd3, 0xc1, 0x19, 0x5c, 0x08, 0x21, 0x42, 0x23, 0x12, 0x68,
+	0xaa, 0xd3, 0x77, 0xa6, 0x03, 0xd6, 0xad, 0x50, 0x55, 0x89, 0xfa, 0x16, 0x3e, 0x80, 0x2b, 0x97,
+	0x3e, 0x89, 0xb8, 0x9a, 0x8d, 0xe0, 0x52, 0xba, 0x77, 0x3e, 0x85, 0x54, 0x3a, 0xc9, 0xf8, 0xb3,
+	0x68, 0x37, 0xe1, 0xe6, 0xf2, 0x9d, 0x53, 0x87, 0xc3, 0xa5, 0x8f, 0x2a, 0xc0, 0x5a, 0xce, 0xb5,
+	0xe0, 0x85, 0xd2, 0xc0, 0x0b, 0x25, 0x2b, 0x85, 0x80, 0x96, 0x5f, 0xd5, 0xb8, 0x28, 0xf1, 0x9a,
+	0x37, 0x51, 0x3f, 0xb2, 0x4a, 0x2b, 0xab, 0xfc, 0xb0, 0x57, 0x30, 0xa7, 0x60, 0x83, 0x82, 0xf5,
+	0x58, 0x13, 0x3d, 0x08, 0xfe, 0x74, 0xc5, 0x5a, 0x3a, 0x1f, 0xac, 0xe5, 0xc6, 0x23, 0xbc, 0x4f,
+	0xef, 0x5d, 0x6c, 0xe8, 0x54, 0x68, 0x21, 0xc1, 0x82, 0x36, 0x21, 0xd2, 0xc3, 0x4b, 0x40, 0x30,
+	0xa5, 0x49, 0x14, 0x5a, 0x40, 0xeb, 0xe7, 0xf4, 0xb0, 0x33, 0x9d, 0x55, 0x8e, 0x33, 0x63, 0x72,
+	0x4c, 0x4e, 0xf7, 0xce, 0x9e, 0xb0, 0xed, 0x19, 0xd8, 0x3f, 0x0f, 0x64, 0x07, 0x57, 0xbf, 0xad,
+	0x4c, 0xf8, 0x91, 0xd0, 0xf1, 0xb3, 0x06, 0xd0, 0x76, 0xe4, 0x4b, 0xab, 0x41, 0xc8, 0x0c, 0xde,
+	0x0a, 0xbd, 0xf0, 0x8f, 0xe8, 0xae, 0x86, 0xa2, 0xac, 0x4a, 0x40, 0xdb, 0xbe, 0xba, 0x9b, 0xdd,
+	0x2e, 0xfc, 0x87, 0x74, 0x0f, 0x2a, 0x55, 0x2c, 0x67, 0x25, 0x2e, 0xe0, 0xdd, 0xd8, 0x3b, 0x26,
+	0xa7, 0x3b, 0x19, 0x6d, 0x57, 0xcf, 0xdd, 0xc6, 0x3f, 0xa7, 0x07, 0xba, 0x35, 0x9a, 0x09, 0xa9,
+	0x6a, 0xb4, 0xe3, 0x3b, 0x6d, 0xf0, 0xa3, 0xbf, 0x82, 0xbb, 0x46, 0x9a, 0x88, 0x9d, 0xb7, 0x4c,
+	0xb6, 0xbf, 0x91, 0x6c, 0xfe, 0x26, 0xdf, 0xbc, 0x2f, 0xab, 0x80, 0xdc, 0xac, 0x02, 0xf2, 0x63,
+	0x15, 0x90, 0x0f, 0xeb, 0x60, 0x74, 0xb3, 0x0e, 0x46, 0xdf, 0xd7, 0xc1, 0x88, 0x9e, 0x14, 0x4a,
+	0xfe, 0x47, 0x05, 0x93, 0xfd, 0xbe, 0x03, 0x57, 0x7a, 0x4a, 0x5e, 0xbf, 0xba, 0x2e, 0xed, 0xb2,
+	0x9e, 0x3b, 0x98, 0x17, 0xca, 0x48, 0x65, 0xb8, 0x86, 0x37, 0xe2, 0x3d, 0x68, 0xde, 0x9c, 0x0d,
+	0x63, 0xb1, 0x14, 0x25, 0x1a, 0xbe, 0xfd, 0x30, 0x9e, 0x76, 0x63, 0x13, 0x7d, 0xf2, 0x76, 0xd2,
+	0x24, 0xb9, 0xf8, 0xec, 0x85, 0x69, 0x9f, 0x2a, 0x71, 0xa9, 0x92, 0x21, 0x55, 0x97, 0x84, 0x4d,
+	0xa3, 0xaf, 0xb7, 0x50, 0xee, 0xa0, 0x7c, 0x80, 0xf2, 0x0e, 0xca, 0xa7, 0xd1, 0xca, 0x63, 0xdb,
+	0xa1, 0xfc, 0x32, 0x9d, 0xbc, 0x00, 0x2b, 0x16, 0xc2, 0x8a, 0x9f, 0xde, 0x49, 0x2f, 0x88, 0x63,
+	0xa7, 0x70, 0xdf, 0x4e, 0x12, 0xc7, 0x9d, 0x26, 0x8e, 0xa7, 0xd1, 0xfc, 0x6e, 0x7b, 0x82, 0x8f,
+	0x7f, 0x05, 0x00, 0x00, 0xff, 0xff, 0xdb, 0xb6, 0x9d, 0x78, 0xfa, 0x02, 0x00, 0x00,
 }
 
 func (m *FundingParameters) Marshal() (dAtA []byte, err error) {
@@ -195,6 +271,53 @@ func (m *GenesisContent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
+func (m *EventFundingStreamReward) 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 *EventFundingStreamReward) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *EventFundingStreamReward) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.RewardAmount != nil {
+		{
+			size, err := m.RewardAmount.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintFunding(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x1a
+	}
+	if m.EpochIndex != 0 {
+		i = encodeVarintFunding(dAtA, i, uint64(m.EpochIndex))
+		i--
+		dAtA[i] = 0x10
+	}
+	if len(m.Recipient) > 0 {
+		i -= len(m.Recipient)
+		copy(dAtA[i:], m.Recipient)
+		i = encodeVarintFunding(dAtA, i, uint64(len(m.Recipient)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
 func encodeVarintFunding(dAtA []byte, offset int, v uint64) int {
 	offset -= sovFunding(v)
 	base := offset
@@ -228,6 +351,26 @@ func (m *GenesisContent) Size() (n int) {
 	return n
 }
 
+func (m *EventFundingStreamReward) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Recipient)
+	if l > 0 {
+		n += 1 + l + sovFunding(uint64(l))
+	}
+	if m.EpochIndex != 0 {
+		n += 1 + sovFunding(uint64(m.EpochIndex))
+	}
+	if m.RewardAmount != nil {
+		l = m.RewardAmount.Size()
+		n += 1 + l + sovFunding(uint64(l))
+	}
+	return n
+}
+
 func sovFunding(x uint64) (n int) {
 	return (math_bits.Len64(x|1) + 6) / 7
 }
@@ -370,6 +513,143 @@ func (m *GenesisContent) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *EventFundingStreamReward) 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 ErrIntOverflowFunding
+			}
+			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: EventFundingStreamReward: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: EventFundingStreamReward: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Recipient", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowFunding
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthFunding
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthFunding
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Recipient = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
+			}
+			m.EpochIndex = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowFunding
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.EpochIndex |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RewardAmount", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowFunding
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthFunding
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthFunding
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.RewardAmount == nil {
+				m.RewardAmount = &v1.Amount{}
+			}
+			if err := m.RewardAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipFunding(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthFunding
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func skipFunding(dAtA []byte) (n int, err error) {
 	l := len(dAtA)
 	iNdEx := 0
diff --git a/relayer/chains/penumbra/core/component/governance/v1/governance.pb.go b/relayer/chains/penumbra/core/component/governance/v1/governance.pb.go
index 394075980..60e770a89 100644
--- a/relayer/chains/penumbra/core/component/governance/v1/governance.pb.go
+++ b/relayer/chains/penumbra/core/component/governance/v1/governance.pb.go
@@ -1755,7 +1755,6 @@ type Proposal struct {
 	// The proposal's payload.
 	//
 	// Types that are valid to be assigned to Payload:
-	//
 	//	*Proposal_Signaling_
 	//	*Proposal_Emergency_
 	//	*Proposal_ParameterChange_
diff --git a/relayer/chains/penumbra/core/component/sct/v1/sct.pb.go b/relayer/chains/penumbra/core/component/sct/v1/sct.pb.go
index 9b98a0be1..399801648 100644
--- a/relayer/chains/penumbra/core/component/sct/v1/sct.pb.go
+++ b/relayer/chains/penumbra/core/component/sct/v1/sct.pb.go
@@ -8,6 +8,7 @@ import (
 	fmt "fmt"
 	grpc1 "github.com/cosmos/gogoproto/grpc"
 	proto "github.com/cosmos/gogoproto/proto"
+	types "github.com/cosmos/gogoproto/types"
 	v1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/crypto/tct/v1"
 	grpc "google.golang.org/grpc"
 	codes "google.golang.org/grpc/codes"
@@ -1034,6 +1035,94 @@ func (m *AnchorByHeightResponse) GetAnchor() *v1.MerkleRoot {
 	return nil
 }
 
+type TimestampByHeightRequest struct {
+	Height uint64 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
+}
+
+func (m *TimestampByHeightRequest) Reset()         { *m = TimestampByHeightRequest{} }
+func (m *TimestampByHeightRequest) String() string { return proto.CompactTextString(m) }
+func (*TimestampByHeightRequest) ProtoMessage()    {}
+func (*TimestampByHeightRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_85f1e312317b2642, []int{14}
+}
+func (m *TimestampByHeightRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *TimestampByHeightRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_TimestampByHeightRequest.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 *TimestampByHeightRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_TimestampByHeightRequest.Merge(m, src)
+}
+func (m *TimestampByHeightRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *TimestampByHeightRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_TimestampByHeightRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_TimestampByHeightRequest proto.InternalMessageInfo
+
+func (m *TimestampByHeightRequest) GetHeight() uint64 {
+	if m != nil {
+		return m.Height
+	}
+	return 0
+}
+
+type TimestampByHeightResponse struct {
+	Timestamp *types.Timestamp `protobuf:"bytes,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
+}
+
+func (m *TimestampByHeightResponse) Reset()         { *m = TimestampByHeightResponse{} }
+func (m *TimestampByHeightResponse) String() string { return proto.CompactTextString(m) }
+func (*TimestampByHeightResponse) ProtoMessage()    {}
+func (*TimestampByHeightResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_85f1e312317b2642, []int{15}
+}
+func (m *TimestampByHeightResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *TimestampByHeightResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_TimestampByHeightResponse.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 *TimestampByHeightResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_TimestampByHeightResponse.Merge(m, src)
+}
+func (m *TimestampByHeightResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *TimestampByHeightResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_TimestampByHeightResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_TimestampByHeightResponse proto.InternalMessageInfo
+
+func (m *TimestampByHeightResponse) GetTimestamp() *types.Timestamp {
+	if m != nil {
+		return m.Timestamp
+	}
+	return nil
+}
+
 func init() {
 	proto.RegisterType((*SctParameters)(nil), "penumbra.core.component.sct.v1.SctParameters")
 	proto.RegisterType((*GenesisContent)(nil), "penumbra.core.component.sct.v1.GenesisContent")
@@ -1054,6 +1143,8 @@ func init() {
 	proto.RegisterType((*EpochByHeightResponse)(nil), "penumbra.core.component.sct.v1.EpochByHeightResponse")
 	proto.RegisterType((*AnchorByHeightRequest)(nil), "penumbra.core.component.sct.v1.AnchorByHeightRequest")
 	proto.RegisterType((*AnchorByHeightResponse)(nil), "penumbra.core.component.sct.v1.AnchorByHeightResponse")
+	proto.RegisterType((*TimestampByHeightRequest)(nil), "penumbra.core.component.sct.v1.TimestampByHeightRequest")
+	proto.RegisterType((*TimestampByHeightResponse)(nil), "penumbra.core.component.sct.v1.TimestampByHeightResponse")
 }
 
 func init() {
@@ -1061,69 +1152,74 @@ func init() {
 }
 
 var fileDescriptor_85f1e312317b2642 = []byte{
-	// 983 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0xcf, 0x6f, 0x1b, 0xc5,
-	0x17, 0xb7, 0xf7, 0x9b, 0xa4, 0xf1, 0x73, 0x92, 0x7e, 0x99, 0x24, 0x95, 0x65, 0xa9, 0xa6, 0x5d,
-	0xa9, 0x22, 0x42, 0x62, 0x37, 0x36, 0x34, 0x42, 0x2e, 0x42, 0x60, 0xb7, 0x8d, 0x23, 0x51, 0x30,
-	0xeb, 0x28, 0x07, 0x14, 0xb1, 0xdd, 0xcc, 0x8e, 0xe3, 0x55, 0xbc, 0x33, 0x9b, 0x99, 0x59, 0x83,
-	0x11, 0x12, 0x7f, 0x01, 0x12, 0x27, 0xfe, 0x00, 0x8e, 0xdc, 0xb9, 0x73, 0x44, 0x9c, 0x7a, 0xe4,
-	0x88, 0x92, 0x1b, 0x7f, 0x05, 0x9a, 0xd9, 0xf1, 0xcf, 0xa6, 0x49, 0x4d, 0x2f, 0x89, 0xdf, 0xdb,
-	0xcf, 0xfb, 0x7c, 0xde, 0x8f, 0x79, 0xa3, 0x81, 0x9d, 0x84, 0xd0, 0x34, 0x3e, 0xe1, 0x81, 0x8b,
-	0x19, 0x27, 0x2e, 0x66, 0x71, 0xc2, 0x28, 0xa1, 0xd2, 0x15, 0x58, 0xba, 0x83, 0xaa, 0xfa, 0xe7,
-	0x24, 0x9c, 0x49, 0x86, 0x2a, 0x23, 0xa4, 0xa3, 0x90, 0xce, 0x18, 0xe9, 0x28, 0xc8, 0xa0, 0x5a,
-	0xbe, 0x37, 0x61, 0xe2, 0xc3, 0x44, 0x32, 0x57, 0x66, 0x0c, 0x72, 0xc4, 0x60, 0xef, 0xc1, 0x7a,
-	0x07, 0xcb, 0x76, 0xc0, 0x83, 0x98, 0x48, 0xc2, 0x05, 0x7a, 0x00, 0x1b, 0x24, 0x61, 0xb8, 0xe7,
-	0x87, 0x29, 0x0f, 0x64, 0xc4, 0x68, 0x29, 0x7f, 0x2f, 0xbf, 0xb3, 0xe4, 0xad, 0x6b, 0xef, 0x63,
-	0xe3, 0xb4, 0xbf, 0x86, 0x8d, 0x7d, 0x42, 0x89, 0x88, 0x44, 0x93, 0x51, 0x49, 0xa8, 0x44, 0x9f,
-	0x01, 0x08, 0x2c, 0xfd, 0x44, 0x51, 0x09, 0x1d, 0x54, 0xac, 0xbd, 0xe7, 0x5c, 0x9f, 0xa0, 0x33,
-	0xa3, 0xed, 0x15, 0x84, 0x31, 0x85, 0xfd, 0x09, 0x2c, 0x3f, 0x51, 0x82, 0x68, 0x0b, 0x96, 0x23,
-	0x1a, 0x92, 0x6f, 0x4d, 0x1a, 0x99, 0x81, 0xee, 0xc3, 0x9a, 0x90, 0x01, 0x97, 0x7e, 0x8f, 0x44,
-	0xa7, 0x3d, 0x59, 0xb2, 0xf4, 0xc7, 0xa2, 0xf6, 0xb5, 0xb4, 0xcb, 0xfe, 0x79, 0x05, 0xfe, 0xdf,
-	0x64, 0x71, 0x1c, 0xc9, 0x98, 0x50, 0xd9, 0x61, 0x29, 0xc7, 0x04, 0x3d, 0x87, 0xa2, 0xe4, 0x01,
-	0x15, 0x01, 0x1e, 0x97, 0x56, 0xac, 0x7d, 0x74, 0x53, 0x96, 0xf3, 0x34, 0xce, 0xe1, 0x84, 0xa3,
-	0x95, 0xf3, 0xa6, 0x29, 0x51, 0x0f, 0x6e, 0x47, 0x58, 0xf8, 0xb5, 0x5d, 0x5f, 0x7b, 0xbb, 0x84,
-	0xeb, 0xe4, 0x8a, 0xb5, 0x8f, 0x17, 0x56, 0x39, 0xc0, 0xa2, 0xb6, 0x7b, 0x68, 0x58, 0x5a, 0x39,
-	0x6f, 0x3d, 0x9a, 0x76, 0xa0, 0xef, 0x60, 0xbb, 0x9b, 0xd2, 0x30, 0xa2, 0xa7, 0xbe, 0x90, 0x9c,
-	0x04, 0xb1, 0xcf, 0xc9, 0x37, 0x01, 0x0f, 0x4b, 0x5b, 0x5a, 0xef, 0xf1, 0xc2, 0x7a, 0x4f, 0x33,
-	0xb6, 0x8e, 0x26, 0xf3, 0x34, 0x57, 0x2b, 0xe7, 0x6d, 0x76, 0x5f, 0x76, 0x2b, 0x6d, 0xcc, 0xe2,
-	0x38, 0xa5, 0x91, 0x1c, 0xfa, 0x09, 0x63, 0x7d, 0x9f, 0xa5, 0x32, 0x49, 0x65, 0xa9, 0xf2, 0x1f,
-	0xb5, 0x9b, 0x23, 0xb6, 0x36, 0x63, 0xfd, 0x2f, 0x34, 0x97, 0xd2, 0xc6, 0x2f, 0xbb, 0xd1, 0x21,
-	0xdc, 0x3a, 0xcd, 0x8e, 0x5e, 0x69, 0x47, 0xab, 0x7d, 0xb8, 0xb0, 0x9a, 0x39, 0xba, 0xad, 0x9c,
-	0x37, 0xa2, 0x2a, 0x17, 0xe0, 0x96, 0xf1, 0x96, 0xef, 0x42, 0x71, 0x6a, 0xc0, 0x68, 0x03, 0xac,
-	0x28, 0xd4, 0x47, 0x65, 0xcd, 0xb3, 0xa2, 0xb0, 0xbc, 0x07, 0x9b, 0x57, 0x74, 0x0a, 0xbd, 0x0d,
-	0xc5, 0x6c, 0x71, 0xa6, 0x8f, 0x2b, 0x68, 0xd7, 0x81, 0xf2, 0x94, 0xb7, 0x61, 0xf3, 0x8a, 0x2a,
-	0xcb, 0x04, 0xd6, 0x67, 0x06, 0x8d, 0xee, 0x02, 0x24, 0x01, 0x3e, 0x23, 0xd2, 0x17, 0xe4, 0xdc,
-	0xf0, 0x14, 0x32, 0x4f, 0x87, 0x9c, 0xab, 0xcf, 0xb8, 0x17, 0x50, 0x4a, 0xfa, 0x7e, 0x14, 0xea,
-	0xb3, 0x55, 0xf0, 0x0a, 0xc6, 0x73, 0x10, 0xa2, 0x3b, 0xb0, 0x22, 0x08, 0x0d, 0x09, 0x2f, 0xfd,
-	0x4f, 0x7f, 0x32, 0x56, 0x63, 0x15, 0x56, 0x84, 0x2e, 0xde, 0xbe, 0x0f, 0x85, 0xcf, 0xd3, 0x7e,
-	0x3f, 0xea, 0x46, 0x84, 0x67, 0xeb, 0x45, 0x09, 0x37, 0xf5, 0x65, 0x86, 0xfd, 0x14, 0xde, 0x32,
-	0x10, 0xac, 0xd7, 0xfd, 0x80, 0x76, 0xd9, 0x7c, 0x1f, 0xf4, 0x0e, 0x26, 0x84, 0x86, 0xf3, 0x3b,
-	0xa8, 0x7c, 0x66, 0x07, 0x7f, 0xcf, 0xc3, 0xed, 0x27, 0x03, 0x42, 0xe5, 0x64, 0x02, 0x68, 0x1f,
-	0x00, 0x8f, 0x2d, 0xb3, 0x81, 0xef, 0x4c, 0x4d, 0x50, 0x5f, 0x54, 0x8e, 0x34, 0xf7, 0x83, 0x0c,
-	0x24, 0x99, 0x04, 0x7b, 0x53, 0xa1, 0xa8, 0x0c, 0xab, 0x09, 0x13, 0x91, 0x5e, 0xe4, 0x4c, 0x7b,
-	0x6c, 0xa3, 0xd6, 0xa8, 0x5a, 0xdd, 0x85, 0x62, 0x6d, 0x77, 0xd1, 0x23, 0xe2, 0x8d, 0xba, 0x15,
-	0x40, 0x51, 0x57, 0xf0, 0x29, 0xc5, 0x3d, 0xc6, 0x51, 0x1d, 0x56, 0x02, 0xfd, 0xcb, 0x64, 0x6e,
-	0xbf, 0x2a, 0xf3, 0x67, 0x84, 0x9f, 0xf5, 0x89, 0xc7, 0x98, 0xf4, 0x4c, 0x84, 0x1a, 0xcd, 0x4c,
-	0xab, 0x8c, 0xa5, 0xee, 0x52, 0x2d, 0xa1, 0x2f, 0x3c, 0x15, 0x81, 0xf6, 0x60, 0x89, 0x33, 0x26,
-	0x17, 0xd0, 0xd0, 0xf8, 0xc9, 0x65, 0x69, 0x4d, 0x5d, 0x96, 0xf6, 0x73, 0xc3, 0xdf, 0xe8, 0x33,
-	0x7c, 0xf6, 0x46, 0xfc, 0xaf, 0xaa, 0xc0, 0x81, 0x2d, 0x9d, 0x7c, 0x63, 0x98, 0x0d, 0xde, 0x23,
-	0xe7, 0x29, 0x11, 0xd3, 0xf8, 0xfc, 0x0c, 0xfe, 0x10, 0xb6, 0xe7, 0xf0, 0x22, 0x61, 0x54, 0x10,
-	0xf4, 0x08, 0x96, 0xf5, 0xc6, 0x98, 0xcc, 0x1e, 0xdc, 0x34, 0xb6, 0xac, 0x65, 0x59, 0x8c, 0xed,
-	0xc2, 0x76, 0x36, 0xa5, 0xd7, 0x4f, 0xe3, 0xce, 0x7c, 0x80, 0xc9, 0xe3, 0x0d, 0xc6, 0x5c, 0xfb,
-	0xd1, 0x82, 0xb5, 0x2f, 0x53, 0xc2, 0x87, 0x1d, 0xc2, 0x07, 0x11, 0x26, 0xe8, 0x07, 0xd8, 0x98,
-	0x95, 0x41, 0x0f, 0x6f, 0xaa, 0xeb, 0xca, 0x3a, 0xca, 0x7b, 0x8b, 0x86, 0x99, 0x6a, 0xbe, 0x87,
-	0xf5, 0x99, 0x76, 0xa3, 0x0f, 0x5e, 0xab, 0xaf, 0xf3, 0xf2, 0x0f, 0x17, 0x8c, 0xca, 0xd4, 0x1b,
-	0xbf, 0x59, 0x7f, 0x5c, 0x54, 0xf2, 0x2f, 0x2e, 0x2a, 0xf9, 0xbf, 0x2f, 0x2a, 0xf9, 0x9f, 0x2e,
-	0x2b, 0xb9, 0x17, 0x97, 0x95, 0xdc, 0x5f, 0x97, 0x95, 0x1c, 0xd8, 0x98, 0xc5, 0x37, 0x90, 0x36,
-	0x56, 0xd5, 0x1b, 0x41, 0xbd, 0x55, 0xda, 0xf9, 0xaf, 0xda, 0xa7, 0x91, 0xec, 0xa5, 0x27, 0x0a,
-	0xe4, 0x62, 0x26, 0x62, 0x26, 0x5c, 0x4e, 0xfa, 0xc1, 0x90, 0x70, 0x77, 0x50, 0x1b, 0xff, 0xc4,
-	0xbd, 0x20, 0xa2, 0xc2, 0xbd, 0xfe, 0x15, 0xf5, 0x48, 0x60, 0x39, 0xa8, 0xfe, 0x62, 0x2d, 0xb5,
-	0x9b, 0xcd, 0xce, 0xaf, 0x56, 0xa5, 0x3d, 0xca, 0xa2, 0xa9, 0xb2, 0x68, 0x8e, 0xb3, 0xe8, 0x60,
-	0xe9, 0x1c, 0x55, 0xff, 0x9c, 0x00, 0x8e, 0x15, 0xe0, 0x78, 0x0c, 0x38, 0xee, 0x60, 0x79, 0x7c,
-	0x54, 0xbd, 0xb0, 0xde, 0xbd, 0x1e, 0x70, 0xbc, 0xdf, 0x6e, 0x3c, 0x23, 0x32, 0x08, 0x03, 0x19,
-	0xfc, 0x63, 0xd9, 0x23, 0x70, 0xbd, 0xae, 0xd0, 0xea, 0xaf, 0x81, 0xd7, 0xeb, 0x1d, 0x2c, 0xeb,
-	0xf5, 0xa3, 0xea, 0xc9, 0x8a, 0x7e, 0xa1, 0xbd, 0xff, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xb3,
-	0xe3, 0x58, 0xd9, 0x0f, 0x0a, 0x00, 0x00,
+	// 1057 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0xcf, 0x6f, 0x1b, 0x45,
+	0x14, 0xb6, 0xdd, 0x24, 0x8d, 0x9f, 0x93, 0x94, 0x4e, 0x92, 0xca, 0xac, 0x54, 0xb7, 0x5d, 0xa9,
+	0x22, 0x42, 0x62, 0x37, 0x36, 0x34, 0x2a, 0x2e, 0x42, 0x60, 0xb7, 0x8d, 0x23, 0x51, 0x30, 0xeb,
+	0x90, 0x03, 0x8a, 0xd8, 0x6e, 0x66, 0xc7, 0xf6, 0x2a, 0xde, 0x99, 0xcd, 0xcc, 0xac, 0x21, 0x08,
+	0x89, 0x2b, 0x47, 0x4e, 0x88, 0x33, 0x47, 0xee, 0xdc, 0x39, 0x22, 0x4e, 0x3d, 0x72, 0x44, 0xc9,
+	0x8d, 0xbf, 0x02, 0xed, 0xec, 0xf8, 0x67, 0x7e, 0xba, 0xbd, 0xd8, 0x3b, 0x6f, 0xbf, 0xf7, 0xbd,
+	0xef, 0xbd, 0x37, 0x6f, 0x66, 0x61, 0x23, 0x22, 0x34, 0x0e, 0x0f, 0xb8, 0x67, 0x63, 0xc6, 0x89,
+	0x8d, 0x59, 0x18, 0x31, 0x4a, 0xa8, 0xb4, 0x05, 0x96, 0x76, 0xbf, 0x9c, 0xfc, 0x59, 0x11, 0x67,
+	0x92, 0xa1, 0xd2, 0x00, 0x69, 0x25, 0x48, 0x6b, 0x88, 0xb4, 0x12, 0x48, 0xbf, 0x6c, 0xdc, 0x1f,
+	0x31, 0xf1, 0xe3, 0x48, 0x32, 0x5b, 0xa6, 0x0c, 0x72, 0xc0, 0x60, 0xdc, 0xeb, 0x30, 0xd6, 0xe9,
+	0x11, 0x5b, 0xad, 0x0e, 0xe2, 0xb6, 0x2d, 0x83, 0x90, 0x08, 0xe9, 0x85, 0x51, 0x0a, 0x30, 0xb7,
+	0x60, 0xb9, 0x85, 0x65, 0xd3, 0xe3, 0x5e, 0x48, 0x24, 0xe1, 0x02, 0x3d, 0x84, 0x15, 0x12, 0x31,
+	0xdc, 0x75, 0xfd, 0x98, 0x7b, 0x32, 0x60, 0xb4, 0x98, 0xbd, 0x9f, 0xdd, 0x98, 0x73, 0x96, 0x95,
+	0xf5, 0xa9, 0x36, 0x9a, 0xdf, 0xc0, 0xca, 0x36, 0xa1, 0x44, 0x04, 0xa2, 0xce, 0xa8, 0x24, 0x54,
+	0xa2, 0xcf, 0x00, 0x04, 0x96, 0x6e, 0x94, 0x50, 0x09, 0xe5, 0x54, 0xa8, 0xbc, 0x67, 0x5d, 0x9e,
+	0x81, 0x35, 0x11, 0xdb, 0xc9, 0x0b, 0xbd, 0x14, 0xe6, 0x27, 0x30, 0xff, 0x2c, 0x09, 0x88, 0xd6,
+	0x60, 0x3e, 0xa0, 0x3e, 0xf9, 0x4e, 0xcb, 0x48, 0x17, 0xe8, 0x01, 0x2c, 0x09, 0xe9, 0x71, 0xe9,
+	0x76, 0x49, 0xd0, 0xe9, 0xca, 0x62, 0x4e, 0xbd, 0x2c, 0x28, 0x5b, 0x43, 0x99, 0xcc, 0x5f, 0x16,
+	0xe0, 0xad, 0x3a, 0x0b, 0xc3, 0x40, 0x86, 0x84, 0xca, 0x16, 0x8b, 0x39, 0x26, 0xe8, 0x25, 0x14,
+	0x24, 0xf7, 0xa8, 0xf0, 0xf0, 0x30, 0xb5, 0x42, 0xe5, 0xa3, 0xab, 0x54, 0x4e, 0xd3, 0x58, 0xbb,
+	0x23, 0x8e, 0x46, 0xc6, 0x19, 0xa7, 0x44, 0x5d, 0xb8, 0x15, 0x60, 0xe1, 0x56, 0x36, 0x5d, 0x65,
+	0x6d, 0x13, 0xae, 0xc4, 0x15, 0x2a, 0x1f, 0xcf, 0x1c, 0x65, 0x07, 0x8b, 0xca, 0xe6, 0xae, 0x66,
+	0x69, 0x64, 0x9c, 0xe5, 0x60, 0xdc, 0x80, 0xbe, 0x87, 0xf5, 0x76, 0x4c, 0xfd, 0x80, 0x76, 0x5c,
+	0x21, 0x39, 0xf1, 0x42, 0x97, 0x93, 0x6f, 0x3d, 0xee, 0x17, 0xd7, 0x54, 0xbc, 0xa7, 0x33, 0xc7,
+	0x7b, 0x9e, 0xb2, 0xb5, 0x14, 0x99, 0xa3, 0xb8, 0x1a, 0x19, 0x67, 0xb5, 0x7d, 0xd6, 0x9c, 0xc4,
+	0xc6, 0x2c, 0x0c, 0x63, 0x1a, 0xc8, 0x63, 0x37, 0x62, 0xac, 0xe7, 0xb2, 0x58, 0x46, 0xb1, 0x2c,
+	0x96, 0x5e, 0x33, 0x76, 0x7d, 0xc0, 0xd6, 0x64, 0xac, 0xf7, 0x85, 0xe2, 0x4a, 0x62, 0xe3, 0xb3,
+	0x66, 0xb4, 0x0b, 0x37, 0x3b, 0xe9, 0xd6, 0x2b, 0x6e, 0xa8, 0x68, 0x8f, 0x67, 0x8e, 0xa6, 0xb7,
+	0x6e, 0x23, 0xe3, 0x0c, 0xa8, 0x8c, 0x3c, 0xdc, 0xd4, 0x56, 0xe3, 0x2e, 0x14, 0xc6, 0x1a, 0x8c,
+	0x56, 0x20, 0x17, 0xf8, 0x6a, 0xab, 0x2c, 0x39, 0xb9, 0xc0, 0x37, 0xb6, 0x60, 0xf5, 0x9c, 0x4a,
+	0xa1, 0x7b, 0x50, 0x48, 0x07, 0x67, 0x7c, 0xbb, 0x82, 0x32, 0xed, 0x24, 0x16, 0x63, 0x1d, 0x56,
+	0xcf, 0xc9, 0xd2, 0x20, 0xb0, 0x3c, 0xd1, 0x68, 0x74, 0x17, 0x20, 0xf2, 0xf0, 0x21, 0x91, 0xae,
+	0x20, 0x47, 0x9a, 0x27, 0x9f, 0x5a, 0x5a, 0xe4, 0x28, 0x79, 0x8d, 0xbb, 0x1e, 0xa5, 0xa4, 0xe7,
+	0x06, 0xbe, 0xda, 0x5b, 0x79, 0x27, 0xaf, 0x2d, 0x3b, 0x3e, 0xba, 0x03, 0x0b, 0x82, 0x50, 0x9f,
+	0xf0, 0xe2, 0x0d, 0xf5, 0x4a, 0xaf, 0x6a, 0x8b, 0xb0, 0x20, 0x54, 0xf2, 0xe6, 0x03, 0xc8, 0x7f,
+	0x1e, 0xf7, 0x7a, 0x41, 0x3b, 0x20, 0x3c, 0x1d, 0x2f, 0x4a, 0xb8, 0xce, 0x2f, 0x5d, 0x98, 0xcf,
+	0xe1, 0xb6, 0x86, 0x60, 0x35, 0xee, 0x3b, 0xb4, 0xcd, 0xa6, 0xeb, 0xa0, 0x66, 0x30, 0x22, 0xd4,
+	0x9f, 0x9e, 0xc1, 0xc4, 0xa6, 0x67, 0xf0, 0xcf, 0x2c, 0xdc, 0x7a, 0xd6, 0x27, 0x54, 0x8e, 0x3a,
+	0x80, 0xb6, 0x01, 0xf0, 0x70, 0xa5, 0x27, 0xf0, 0x9d, 0xb1, 0x0e, 0xaa, 0x93, 0xcc, 0x92, 0xfa,
+	0x7c, 0x90, 0x9e, 0x24, 0x23, 0x67, 0x67, 0xcc, 0x15, 0x19, 0xb0, 0x18, 0x31, 0x11, 0xa8, 0x41,
+	0x4e, 0x63, 0x0f, 0xd7, 0xa8, 0x31, 0xc8, 0x56, 0x55, 0xa1, 0x50, 0xd9, 0x9c, 0x75, 0x8b, 0x38,
+	0x83, 0x6a, 0x79, 0x50, 0x50, 0x19, 0x7c, 0x4a, 0x71, 0x97, 0x71, 0x54, 0x85, 0x05, 0x4f, 0x3d,
+	0x69, 0xe5, 0xe6, 0x45, 0xca, 0x5f, 0x10, 0x7e, 0xd8, 0x23, 0x0e, 0x63, 0xd2, 0xd1, 0x1e, 0x49,
+	0x6b, 0x26, 0x4a, 0xa5, 0x57, 0xc9, 0x59, 0xaa, 0x42, 0xa8, 0x03, 0x2f, 0xf1, 0x40, 0x5b, 0x30,
+	0xc7, 0x19, 0x93, 0x33, 0xc4, 0x50, 0xf8, 0xd1, 0x61, 0x99, 0x1b, 0x3b, 0x2c, 0xcd, 0x97, 0x9a,
+	0xbf, 0xd6, 0x63, 0xf8, 0xf0, 0x8d, 0xf8, 0x2f, 0xca, 0xc0, 0x82, 0x35, 0x25, 0xbe, 0x76, 0x9c,
+	0x36, 0xde, 0x21, 0x47, 0x31, 0x11, 0xe3, 0xf8, 0xec, 0x04, 0x7e, 0x17, 0xd6, 0xa7, 0xf0, 0x22,
+	0x62, 0x54, 0x10, 0xf4, 0x04, 0xe6, 0xd5, 0xc4, 0x68, 0x65, 0x0f, 0xaf, 0x6a, 0x5b, 0x5a, 0xb2,
+	0xd4, 0xc7, 0xb4, 0x61, 0x3d, 0xed, 0xd2, 0xf5, 0x65, 0xdc, 0x99, 0x76, 0xd0, 0x3a, 0xde, 0xa0,
+	0xcd, 0x66, 0x05, 0x8a, 0xbb, 0x83, 0x5b, 0xf6, 0xba, 0x4a, 0xbe, 0x82, 0xb7, 0xcf, 0xf1, 0xd1,
+	0x62, 0x1e, 0x43, 0x7e, 0x78, 0x6d, 0x6b, 0x3d, 0x86, 0x95, 0x5e, 0xec, 0xd6, 0xe0, 0x62, 0xb7,
+	0x86, 0xee, 0xce, 0x08, 0x5c, 0xf9, 0xf5, 0x06, 0x2c, 0x7d, 0x19, 0x13, 0x7e, 0xdc, 0x22, 0xbc,
+	0x1f, 0x60, 0x82, 0x7e, 0x84, 0x95, 0xc9, 0x8c, 0xd1, 0xa3, 0xab, 0x4a, 0x7c, 0x6e, 0x49, 0x8d,
+	0xad, 0x59, 0xdd, 0x74, 0x2e, 0x3f, 0xc0, 0xf2, 0x44, 0xe7, 0xd1, 0x07, 0xd7, 0x6a, 0xf1, 0x74,
+	0xf8, 0x47, 0x33, 0x7a, 0xe9, 0xe8, 0x3f, 0x65, 0xe1, 0xf6, 0x99, 0x3a, 0xa3, 0x2b, 0xef, 0x8f,
+	0x8b, 0xda, 0x69, 0x7c, 0xf8, 0x1a, 0x9e, 0xa9, 0x94, 0xda, 0x1f, 0xb9, 0xbf, 0x4e, 0x4a, 0xd9,
+	0x57, 0x27, 0xa5, 0xec, 0xbf, 0x27, 0xa5, 0xec, 0xcf, 0xa7, 0xa5, 0xcc, 0xab, 0xd3, 0x52, 0xe6,
+	0x9f, 0xd3, 0x52, 0x06, 0x4c, 0xcc, 0xc2, 0x2b, 0x88, 0x6b, 0x8b, 0xc9, 0x97, 0x53, 0xd2, 0xfb,
+	0x66, 0xf6, 0xeb, 0x66, 0x27, 0x90, 0xdd, 0xf8, 0x20, 0x01, 0xd9, 0x98, 0x89, 0x90, 0x09, 0x9b,
+	0x93, 0x9e, 0x77, 0x4c, 0xb8, 0xdd, 0xaf, 0x0c, 0x1f, 0x71, 0xd7, 0x0b, 0xa8, 0xb0, 0x2f, 0xff,
+	0xf8, 0x7c, 0x22, 0xb0, 0xec, 0x97, 0x7f, 0xcb, 0xcd, 0x35, 0xeb, 0xf5, 0xd6, 0xef, 0xb9, 0x52,
+	0x73, 0xa0, 0xa2, 0x9e, 0xa8, 0xa8, 0x0f, 0x55, 0xb4, 0xb0, 0xb4, 0xf6, 0xca, 0x7f, 0x8f, 0x00,
+	0xfb, 0x09, 0x60, 0x7f, 0x08, 0xd8, 0x6f, 0x61, 0xb9, 0xbf, 0x57, 0x3e, 0xc9, 0xbd, 0x7b, 0x39,
+	0x60, 0x7f, 0xbb, 0x59, 0x7b, 0x41, 0xa4, 0xe7, 0x7b, 0xd2, 0xfb, 0x2f, 0x67, 0x0e, 0xc0, 0xd5,
+	0x6a, 0x82, 0x4e, 0x7e, 0x35, 0xbc, 0x5a, 0x6d, 0x61, 0x59, 0xad, 0xee, 0x95, 0x0f, 0x16, 0xd4,
+	0x8e, 0x7f, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x4d, 0x49, 0x80, 0x4e, 0x46, 0x0b, 0x00,
+	0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -1140,6 +1236,7 @@ const _ = grpc.SupportPackageIsVersion4
 type QueryServiceClient interface {
 	AnchorByHeight(ctx context.Context, in *AnchorByHeightRequest, opts ...grpc.CallOption) (*AnchorByHeightResponse, error)
 	EpochByHeight(ctx context.Context, in *EpochByHeightRequest, opts ...grpc.CallOption) (*EpochByHeightResponse, error)
+	TimestampByHeight(ctx context.Context, in *TimestampByHeightRequest, opts ...grpc.CallOption) (*TimestampByHeightResponse, error)
 }
 
 type queryServiceClient struct {
@@ -1168,10 +1265,20 @@ func (c *queryServiceClient) EpochByHeight(ctx context.Context, in *EpochByHeigh
 	return out, nil
 }
 
+func (c *queryServiceClient) TimestampByHeight(ctx context.Context, in *TimestampByHeightRequest, opts ...grpc.CallOption) (*TimestampByHeightResponse, error) {
+	out := new(TimestampByHeightResponse)
+	err := c.cc.Invoke(ctx, "/penumbra.core.component.sct.v1.QueryService/TimestampByHeight", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // QueryServiceServer is the server API for QueryService service.
 type QueryServiceServer interface {
 	AnchorByHeight(context.Context, *AnchorByHeightRequest) (*AnchorByHeightResponse, error)
 	EpochByHeight(context.Context, *EpochByHeightRequest) (*EpochByHeightResponse, error)
+	TimestampByHeight(context.Context, *TimestampByHeightRequest) (*TimestampByHeightResponse, error)
 }
 
 // UnimplementedQueryServiceServer can be embedded to have forward compatible implementations.
@@ -1184,6 +1291,9 @@ func (*UnimplementedQueryServiceServer) AnchorByHeight(ctx context.Context, req
 func (*UnimplementedQueryServiceServer) EpochByHeight(ctx context.Context, req *EpochByHeightRequest) (*EpochByHeightResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method EpochByHeight not implemented")
 }
+func (*UnimplementedQueryServiceServer) TimestampByHeight(ctx context.Context, req *TimestampByHeightRequest) (*TimestampByHeightResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method TimestampByHeight not implemented")
+}
 
 func RegisterQueryServiceServer(s grpc1.Server, srv QueryServiceServer) {
 	s.RegisterService(&_QueryService_serviceDesc, srv)
@@ -1225,6 +1335,24 @@ func _QueryService_EpochByHeight_Handler(srv interface{}, ctx context.Context, d
 	return interceptor(ctx, in, info, handler)
 }
 
+func _QueryService_TimestampByHeight_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(TimestampByHeightRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServiceServer).TimestampByHeight(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/penumbra.core.component.sct.v1.QueryService/TimestampByHeight",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServiceServer).TimestampByHeight(ctx, req.(*TimestampByHeightRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _QueryService_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "penumbra.core.component.sct.v1.QueryService",
 	HandlerType: (*QueryServiceServer)(nil),
@@ -1237,6 +1365,10 @@ var _QueryService_serviceDesc = grpc.ServiceDesc{
 			MethodName: "EpochByHeight",
 			Handler:    _QueryService_EpochByHeight_Handler,
 		},
+		{
+			MethodName: "TimestampByHeight",
+			Handler:    _QueryService_TimestampByHeight_Handler,
+		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "penumbra/core/component/sct/v1/sct.proto",
@@ -1990,6 +2122,69 @@ func (m *AnchorByHeightResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)
 	return len(dAtA) - i, nil
 }
 
+func (m *TimestampByHeightRequest) 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 *TimestampByHeightRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TimestampByHeightRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.Height != 0 {
+		i = encodeVarintSct(dAtA, i, uint64(m.Height))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *TimestampByHeightResponse) 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 *TimestampByHeightResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TimestampByHeightResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.Timestamp != nil {
+		{
+			size, err := m.Timestamp.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintSct(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
 func encodeVarintSct(dAtA []byte, offset int, v uint64) int {
 	offset -= sovSct(v)
 	base := offset
@@ -2323,6 +2518,31 @@ func (m *AnchorByHeightResponse) Size() (n int) {
 	return n
 }
 
+func (m *TimestampByHeightRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Height != 0 {
+		n += 1 + sovSct(uint64(m.Height))
+	}
+	return n
+}
+
+func (m *TimestampByHeightResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Timestamp != nil {
+		l = m.Timestamp.Size()
+		n += 1 + l + sovSct(uint64(l))
+	}
+	return n
+}
+
 func sovSct(x uint64) (n int) {
 	return (math_bits.Len64(x|1) + 6) / 7
 }
@@ -4136,6 +4356,161 @@ func (m *AnchorByHeightResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *TimestampByHeightRequest) 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 ErrIntOverflowSct
+			}
+			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: TimestampByHeightRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: TimestampByHeightRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
+			}
+			m.Height = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSct
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Height |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipSct(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthSct
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *TimestampByHeightResponse) 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 ErrIntOverflowSct
+			}
+			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: TimestampByHeightResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: TimestampByHeightResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSct
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthSct
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthSct
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Timestamp == nil {
+				m.Timestamp = &types.Timestamp{}
+			}
+			if err := m.Timestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipSct(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthSct
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func skipSct(dAtA []byte) (n int, err error) {
 	l := len(dAtA)
 	iNdEx := 0
diff --git a/relayer/chains/penumbra/core/component/shielded_pool/v1/shielded_pool.pb.go b/relayer/chains/penumbra/core/component/shielded_pool/v1/shielded_pool.pb.go
index cd11cb621..3251ead53 100644
--- a/relayer/chains/penumbra/core/component/shielded_pool/v1/shielded_pool.pb.go
+++ b/relayer/chains/penumbra/core/component/shielded_pool/v1/shielded_pool.pb.go
@@ -212,6 +212,7 @@ type FmdMetaParameters struct {
 	// Types that are valid to be assigned to Algorithm:
 	//
 	//	*FmdMetaParameters_FixedPrecisionBits
+	//	*FmdMetaParameters_SlidingWindow
 	Algorithm isFmdMetaParameters_Algorithm `protobuf_oneof:"algorithm"`
 }
 
@@ -257,8 +258,12 @@ type isFmdMetaParameters_Algorithm interface {
 type FmdMetaParameters_FixedPrecisionBits struct {
 	FixedPrecisionBits uint32 `protobuf:"varint,2,opt,name=fixed_precision_bits,json=fixedPrecisionBits,proto3,oneof" json:"fixed_precision_bits,omitempty"`
 }
+type FmdMetaParameters_SlidingWindow struct {
+	SlidingWindow *FmdMetaParameters_AlgorithmSlidingWindow `protobuf:"bytes,3,opt,name=sliding_window,json=slidingWindow,proto3,oneof" json:"sliding_window,omitempty"`
+}
 
 func (*FmdMetaParameters_FixedPrecisionBits) isFmdMetaParameters_Algorithm() {}
+func (*FmdMetaParameters_SlidingWindow) isFmdMetaParameters_Algorithm()      {}
 
 func (m *FmdMetaParameters) GetAlgorithm() isFmdMetaParameters_Algorithm {
 	if m != nil {
@@ -281,12 +286,257 @@ func (m *FmdMetaParameters) GetFixedPrecisionBits() uint32 {
 	return 0
 }
 
+func (m *FmdMetaParameters) GetSlidingWindow() *FmdMetaParameters_AlgorithmSlidingWindow {
+	if x, ok := m.GetAlgorithm().(*FmdMetaParameters_SlidingWindow); ok {
+		return x.SlidingWindow
+	}
+	return nil
+}
+
 // XXX_OneofWrappers is for the internal use of the proto package.
 func (*FmdMetaParameters) XXX_OneofWrappers() []interface{} {
 	return []interface{}{
 		(*FmdMetaParameters_FixedPrecisionBits)(nil),
+		(*FmdMetaParameters_SlidingWindow)(nil),
+	}
+}
+
+// A sliding window algorithm for updating the parameters.
+type FmdMetaParameters_AlgorithmSlidingWindow struct {
+	// The window size, in terms of the number of update periods.
+	//
+	// The update period is 16 blocks, by default, but can change with governance.
+	WindowUpdatePeriods uint32 `protobuf:"varint,1,opt,name=window_update_periods,json=windowUpdatePeriods,proto3" json:"window_update_periods,omitempty"`
+	// The number of detections we aim to see per window.
+	TargetedDetectionsPerWindow uint32 `protobuf:"varint,2,opt,name=targeted_detections_per_window,json=targetedDetectionsPerWindow,proto3" json:"targeted_detections_per_window,omitempty"`
+}
+
+func (m *FmdMetaParameters_AlgorithmSlidingWindow) Reset() {
+	*m = FmdMetaParameters_AlgorithmSlidingWindow{}
+}
+func (m *FmdMetaParameters_AlgorithmSlidingWindow) String() string { return proto.CompactTextString(m) }
+func (*FmdMetaParameters_AlgorithmSlidingWindow) ProtoMessage()    {}
+func (*FmdMetaParameters_AlgorithmSlidingWindow) Descriptor() ([]byte, []int) {
+	return fileDescriptor_26a9f446de1cd73c, []int{2, 0}
+}
+func (m *FmdMetaParameters_AlgorithmSlidingWindow) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *FmdMetaParameters_AlgorithmSlidingWindow) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_FmdMetaParameters_AlgorithmSlidingWindow.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 *FmdMetaParameters_AlgorithmSlidingWindow) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_FmdMetaParameters_AlgorithmSlidingWindow.Merge(m, src)
+}
+func (m *FmdMetaParameters_AlgorithmSlidingWindow) XXX_Size() int {
+	return m.Size()
+}
+func (m *FmdMetaParameters_AlgorithmSlidingWindow) XXX_DiscardUnknown() {
+	xxx_messageInfo_FmdMetaParameters_AlgorithmSlidingWindow.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FmdMetaParameters_AlgorithmSlidingWindow proto.InternalMessageInfo
+
+func (m *FmdMetaParameters_AlgorithmSlidingWindow) GetWindowUpdatePeriods() uint32 {
+	if m != nil {
+		return m.WindowUpdatePeriods
+	}
+	return 0
+}
+
+func (m *FmdMetaParameters_AlgorithmSlidingWindow) GetTargetedDetectionsPerWindow() uint32 {
+	if m != nil {
+		return m.TargetedDetectionsPerWindow
+	}
+	return 0
+}
+
+// Used to potentially store state for the FMD Meta Parameters algorithm.
+type FmdMetaParametersAlgorithmState struct {
+	// Types that are valid to be assigned to State:
+	//
+	//	*FmdMetaParametersAlgorithmState_Fixed
+	//	*FmdMetaParametersAlgorithmState_SlidingWindow
+	State isFmdMetaParametersAlgorithmState_State `protobuf_oneof:"state"`
+}
+
+func (m *FmdMetaParametersAlgorithmState) Reset()         { *m = FmdMetaParametersAlgorithmState{} }
+func (m *FmdMetaParametersAlgorithmState) String() string { return proto.CompactTextString(m) }
+func (*FmdMetaParametersAlgorithmState) ProtoMessage()    {}
+func (*FmdMetaParametersAlgorithmState) Descriptor() ([]byte, []int) {
+	return fileDescriptor_26a9f446de1cd73c, []int{3}
+}
+func (m *FmdMetaParametersAlgorithmState) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *FmdMetaParametersAlgorithmState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_FmdMetaParametersAlgorithmState.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 *FmdMetaParametersAlgorithmState) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_FmdMetaParametersAlgorithmState.Merge(m, src)
+}
+func (m *FmdMetaParametersAlgorithmState) XXX_Size() int {
+	return m.Size()
+}
+func (m *FmdMetaParametersAlgorithmState) XXX_DiscardUnknown() {
+	xxx_messageInfo_FmdMetaParametersAlgorithmState.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FmdMetaParametersAlgorithmState proto.InternalMessageInfo
+
+type isFmdMetaParametersAlgorithmState_State interface {
+	isFmdMetaParametersAlgorithmState_State()
+	MarshalTo([]byte) (int, error)
+	Size() int
+}
+
+type FmdMetaParametersAlgorithmState_Fixed struct {
+	Fixed *FmdMetaParametersAlgorithmState_FixedState `protobuf:"bytes,1,opt,name=fixed,proto3,oneof" json:"fixed,omitempty"`
+}
+type FmdMetaParametersAlgorithmState_SlidingWindow struct {
+	SlidingWindow *FmdMetaParametersAlgorithmState_SlidingWindowState `protobuf:"bytes,2,opt,name=sliding_window,json=slidingWindow,proto3,oneof" json:"sliding_window,omitempty"`
+}
+
+func (*FmdMetaParametersAlgorithmState_Fixed) isFmdMetaParametersAlgorithmState_State()         {}
+func (*FmdMetaParametersAlgorithmState_SlidingWindow) isFmdMetaParametersAlgorithmState_State() {}
+
+func (m *FmdMetaParametersAlgorithmState) GetState() isFmdMetaParametersAlgorithmState_State {
+	if m != nil {
+		return m.State
+	}
+	return nil
+}
+
+func (m *FmdMetaParametersAlgorithmState) GetFixed() *FmdMetaParametersAlgorithmState_FixedState {
+	if x, ok := m.GetState().(*FmdMetaParametersAlgorithmState_Fixed); ok {
+		return x.Fixed
+	}
+	return nil
+}
+
+func (m *FmdMetaParametersAlgorithmState) GetSlidingWindow() *FmdMetaParametersAlgorithmState_SlidingWindowState {
+	if x, ok := m.GetState().(*FmdMetaParametersAlgorithmState_SlidingWindow); ok {
+		return x.SlidingWindow
+	}
+	return nil
+}
+
+// XXX_OneofWrappers is for the internal use of the proto package.
+func (*FmdMetaParametersAlgorithmState) XXX_OneofWrappers() []interface{} {
+	return []interface{}{
+		(*FmdMetaParametersAlgorithmState_Fixed)(nil),
+		(*FmdMetaParametersAlgorithmState_SlidingWindow)(nil),
+	}
+}
+
+// The state used for the fixed algorithm.
+type FmdMetaParametersAlgorithmState_FixedState struct {
+}
+
+func (m *FmdMetaParametersAlgorithmState_FixedState) Reset() {
+	*m = FmdMetaParametersAlgorithmState_FixedState{}
+}
+func (m *FmdMetaParametersAlgorithmState_FixedState) String() string {
+	return proto.CompactTextString(m)
+}
+func (*FmdMetaParametersAlgorithmState_FixedState) ProtoMessage() {}
+func (*FmdMetaParametersAlgorithmState_FixedState) Descriptor() ([]byte, []int) {
+	return fileDescriptor_26a9f446de1cd73c, []int{3, 0}
+}
+func (m *FmdMetaParametersAlgorithmState_FixedState) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *FmdMetaParametersAlgorithmState_FixedState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_FmdMetaParametersAlgorithmState_FixedState.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 *FmdMetaParametersAlgorithmState_FixedState) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_FmdMetaParametersAlgorithmState_FixedState.Merge(m, src)
+}
+func (m *FmdMetaParametersAlgorithmState_FixedState) XXX_Size() int {
+	return m.Size()
+}
+func (m *FmdMetaParametersAlgorithmState_FixedState) XXX_DiscardUnknown() {
+	xxx_messageInfo_FmdMetaParametersAlgorithmState_FixedState.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FmdMetaParametersAlgorithmState_FixedState proto.InternalMessageInfo
+
+// The state used for the sliding window algorithm.
+type FmdMetaParametersAlgorithmState_SlidingWindowState struct {
+	// The number of clues previously observed, approximately.
+	ApproximateClueCount uint32 `protobuf:"varint,1,opt,name=approximate_clue_count,json=approximateClueCount,proto3" json:"approximate_clue_count,omitempty"`
+}
+
+func (m *FmdMetaParametersAlgorithmState_SlidingWindowState) Reset() {
+	*m = FmdMetaParametersAlgorithmState_SlidingWindowState{}
+}
+func (m *FmdMetaParametersAlgorithmState_SlidingWindowState) String() string {
+	return proto.CompactTextString(m)
+}
+func (*FmdMetaParametersAlgorithmState_SlidingWindowState) ProtoMessage() {}
+func (*FmdMetaParametersAlgorithmState_SlidingWindowState) Descriptor() ([]byte, []int) {
+	return fileDescriptor_26a9f446de1cd73c, []int{3, 1}
+}
+func (m *FmdMetaParametersAlgorithmState_SlidingWindowState) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *FmdMetaParametersAlgorithmState_SlidingWindowState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_FmdMetaParametersAlgorithmState_SlidingWindowState.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 *FmdMetaParametersAlgorithmState_SlidingWindowState) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_FmdMetaParametersAlgorithmState_SlidingWindowState.Merge(m, src)
+}
+func (m *FmdMetaParametersAlgorithmState_SlidingWindowState) XXX_Size() int {
+	return m.Size()
+}
+func (m *FmdMetaParametersAlgorithmState_SlidingWindowState) XXX_DiscardUnknown() {
+	xxx_messageInfo_FmdMetaParametersAlgorithmState_SlidingWindowState.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FmdMetaParametersAlgorithmState_SlidingWindowState proto.InternalMessageInfo
+
+func (m *FmdMetaParametersAlgorithmState_SlidingWindowState) GetApproximateClueCount() uint32 {
+	if m != nil {
+		return m.ApproximateClueCount
+	}
+	return 0
+}
 
 // Parameters for Fuzzy Message Detection
 type FmdParameters struct {
@@ -298,7 +548,7 @@ func (m *FmdParameters) Reset()         { *m = FmdParameters{} }
 func (m *FmdParameters) String() string { return proto.CompactTextString(m) }
 func (*FmdParameters) ProtoMessage()    {}
 func (*FmdParameters) Descriptor() ([]byte, []int) {
-	return fileDescriptor_26a9f446de1cd73c, []int{3}
+	return fileDescriptor_26a9f446de1cd73c, []int{4}
 }
 func (m *FmdParameters) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -351,7 +601,7 @@ func (m *Note) Reset()         { *m = Note{} }
 func (m *Note) String() string { return proto.CompactTextString(m) }
 func (*Note) ProtoMessage()    {}
 func (*Note) Descriptor() ([]byte, []int) {
-	return fileDescriptor_26a9f446de1cd73c, []int{4}
+	return fileDescriptor_26a9f446de1cd73c, []int{5}
 }
 func (m *Note) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -411,7 +661,7 @@ func (m *NoteView) Reset()         { *m = NoteView{} }
 func (m *NoteView) String() string { return proto.CompactTextString(m) }
 func (*NoteView) ProtoMessage()    {}
 func (*NoteView) Descriptor() ([]byte, []int) {
-	return fileDescriptor_26a9f446de1cd73c, []int{5}
+	return fileDescriptor_26a9f446de1cd73c, []int{6}
 }
 func (m *NoteView) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -471,7 +721,7 @@ func (m *NoteCiphertext) Reset()         { *m = NoteCiphertext{} }
 func (m *NoteCiphertext) String() string { return proto.CompactTextString(m) }
 func (*NoteCiphertext) ProtoMessage()    {}
 func (*NoteCiphertext) Descriptor() ([]byte, []int) {
-	return fileDescriptor_26a9f446de1cd73c, []int{6}
+	return fileDescriptor_26a9f446de1cd73c, []int{7}
 }
 func (m *NoteCiphertext) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -523,7 +773,7 @@ func (m *NotePayload) Reset()         { *m = NotePayload{} }
 func (m *NotePayload) String() string { return proto.CompactTextString(m) }
 func (*NotePayload) ProtoMessage()    {}
 func (*NotePayload) Descriptor() ([]byte, []int) {
-	return fileDescriptor_26a9f446de1cd73c, []int{7}
+	return fileDescriptor_26a9f446de1cd73c, []int{8}
 }
 func (m *NotePayload) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -582,7 +832,7 @@ func (m *ZKOutputProof) Reset()         { *m = ZKOutputProof{} }
 func (m *ZKOutputProof) String() string { return proto.CompactTextString(m) }
 func (*ZKOutputProof) ProtoMessage()    {}
 func (*ZKOutputProof) Descriptor() ([]byte, []int) {
-	return fileDescriptor_26a9f446de1cd73c, []int{8}
+	return fileDescriptor_26a9f446de1cd73c, []int{9}
 }
 func (m *ZKOutputProof) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -627,7 +877,7 @@ func (m *ZKSpendProof) Reset()         { *m = ZKSpendProof{} }
 func (m *ZKSpendProof) String() string { return proto.CompactTextString(m) }
 func (*ZKSpendProof) ProtoMessage()    {}
 func (*ZKSpendProof) Descriptor() ([]byte, []int) {
-	return fileDescriptor_26a9f446de1cd73c, []int{9}
+	return fileDescriptor_26a9f446de1cd73c, []int{10}
 }
 func (m *ZKSpendProof) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -672,7 +922,7 @@ func (m *ZKNullifierDerivationProof) Reset()         { *m = ZKNullifierDerivatio
 func (m *ZKNullifierDerivationProof) String() string { return proto.CompactTextString(m) }
 func (*ZKNullifierDerivationProof) ProtoMessage()    {}
 func (*ZKNullifierDerivationProof) Descriptor() ([]byte, []int) {
-	return fileDescriptor_26a9f446de1cd73c, []int{10}
+	return fileDescriptor_26a9f446de1cd73c, []int{11}
 }
 func (m *ZKNullifierDerivationProof) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -722,7 +972,7 @@ func (m *Spend) Reset()         { *m = Spend{} }
 func (m *Spend) String() string { return proto.CompactTextString(m) }
 func (*Spend) ProtoMessage()    {}
 func (*Spend) Descriptor() ([]byte, []int) {
-	return fileDescriptor_26a9f446de1cd73c, []int{11}
+	return fileDescriptor_26a9f446de1cd73c, []int{12}
 }
 func (m *Spend) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -781,7 +1031,7 @@ func (m *EventSpend) Reset()         { *m = EventSpend{} }
 func (m *EventSpend) String() string { return proto.CompactTextString(m) }
 func (*EventSpend) ProtoMessage()    {}
 func (*EventSpend) Descriptor() ([]byte, []int) {
-	return fileDescriptor_26a9f446de1cd73c, []int{12}
+	return fileDescriptor_26a9f446de1cd73c, []int{13}
 }
 func (m *EventSpend) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -826,7 +1076,7 @@ func (m *EventOutput) Reset()         { *m = EventOutput{} }
 func (m *EventOutput) String() string { return proto.CompactTextString(m) }
 func (*EventOutput) ProtoMessage()    {}
 func (*EventOutput) Descriptor() ([]byte, []int) {
-	return fileDescriptor_26a9f446de1cd73c, []int{13}
+	return fileDescriptor_26a9f446de1cd73c, []int{14}
 }
 func (m *EventOutput) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -872,7 +1122,7 @@ func (m *EventBroadcastClue) Reset()         { *m = EventBroadcastClue{} }
 func (m *EventBroadcastClue) String() string { return proto.CompactTextString(m) }
 func (*EventBroadcastClue) ProtoMessage()    {}
 func (*EventBroadcastClue) Descriptor() ([]byte, []int) {
-	return fileDescriptor_26a9f446de1cd73c, []int{14}
+	return fileDescriptor_26a9f446de1cd73c, []int{15}
 }
 func (m *EventBroadcastClue) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -931,7 +1181,7 @@ func (m *SpendBody) Reset()         { *m = SpendBody{} }
 func (m *SpendBody) String() string { return proto.CompactTextString(m) }
 func (*SpendBody) ProtoMessage()    {}
 func (*SpendBody) Descriptor() ([]byte, []int) {
-	return fileDescriptor_26a9f446de1cd73c, []int{15}
+	return fileDescriptor_26a9f446de1cd73c, []int{16}
 }
 func (m *SpendBody) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -993,7 +1243,7 @@ func (m *SpendView) Reset()         { *m = SpendView{} }
 func (m *SpendView) String() string { return proto.CompactTextString(m) }
 func (*SpendView) ProtoMessage()    {}
 func (*SpendView) Descriptor() ([]byte, []int) {
-	return fileDescriptor_26a9f446de1cd73c, []int{16}
+	return fileDescriptor_26a9f446de1cd73c, []int{17}
 }
 func (m *SpendView) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1076,7 +1326,7 @@ func (m *SpendView_Visible) Reset()         { *m = SpendView_Visible{} }
 func (m *SpendView_Visible) String() string { return proto.CompactTextString(m) }
 func (*SpendView_Visible) ProtoMessage()    {}
 func (*SpendView_Visible) Descriptor() ([]byte, []int) {
-	return fileDescriptor_26a9f446de1cd73c, []int{16, 0}
+	return fileDescriptor_26a9f446de1cd73c, []int{17, 0}
 }
 func (m *SpendView_Visible) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1127,7 +1377,7 @@ func (m *SpendView_Opaque) Reset()         { *m = SpendView_Opaque{} }
 func (m *SpendView_Opaque) String() string { return proto.CompactTextString(m) }
 func (*SpendView_Opaque) ProtoMessage()    {}
 func (*SpendView_Opaque) Descriptor() ([]byte, []int) {
-	return fileDescriptor_26a9f446de1cd73c, []int{16, 1}
+	return fileDescriptor_26a9f446de1cd73c, []int{17, 1}
 }
 func (m *SpendView_Opaque) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1182,7 +1432,7 @@ func (m *SpendPlan) Reset()         { *m = SpendPlan{} }
 func (m *SpendPlan) String() string { return proto.CompactTextString(m) }
 func (*SpendPlan) ProtoMessage()    {}
 func (*SpendPlan) Descriptor() ([]byte, []int) {
-	return fileDescriptor_26a9f446de1cd73c, []int{17}
+	return fileDescriptor_26a9f446de1cd73c, []int{18}
 }
 func (m *SpendPlan) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1265,7 +1515,7 @@ func (m *Output) Reset()         { *m = Output{} }
 func (m *Output) String() string { return proto.CompactTextString(m) }
 func (*Output) ProtoMessage()    {}
 func (*Output) Descriptor() ([]byte, []int) {
-	return fileDescriptor_26a9f446de1cd73c, []int{18}
+	return fileDescriptor_26a9f446de1cd73c, []int{19}
 }
 func (m *Output) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1327,7 +1577,7 @@ func (m *OutputBody) Reset()         { *m = OutputBody{} }
 func (m *OutputBody) String() string { return proto.CompactTextString(m) }
 func (*OutputBody) ProtoMessage()    {}
 func (*OutputBody) Descriptor() ([]byte, []int) {
-	return fileDescriptor_26a9f446de1cd73c, []int{19}
+	return fileDescriptor_26a9f446de1cd73c, []int{20}
 }
 func (m *OutputBody) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1396,7 +1646,7 @@ func (m *OutputView) Reset()         { *m = OutputView{} }
 func (m *OutputView) String() string { return proto.CompactTextString(m) }
 func (*OutputView) ProtoMessage()    {}
 func (*OutputView) Descriptor() ([]byte, []int) {
-	return fileDescriptor_26a9f446de1cd73c, []int{20}
+	return fileDescriptor_26a9f446de1cd73c, []int{21}
 }
 func (m *OutputView) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1480,7 +1730,7 @@ func (m *OutputView_Visible) Reset()         { *m = OutputView_Visible{} }
 func (m *OutputView_Visible) String() string { return proto.CompactTextString(m) }
 func (*OutputView_Visible) ProtoMessage()    {}
 func (*OutputView_Visible) Descriptor() ([]byte, []int) {
-	return fileDescriptor_26a9f446de1cd73c, []int{20, 0}
+	return fileDescriptor_26a9f446de1cd73c, []int{21, 0}
 }
 func (m *OutputView_Visible) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1538,7 +1788,7 @@ func (m *OutputView_Opaque) Reset()         { *m = OutputView_Opaque{} }
 func (m *OutputView_Opaque) String() string { return proto.CompactTextString(m) }
 func (*OutputView_Opaque) ProtoMessage()    {}
 func (*OutputView_Opaque) Descriptor() ([]byte, []int) {
-	return fileDescriptor_26a9f446de1cd73c, []int{20, 1}
+	return fileDescriptor_26a9f446de1cd73c, []int{21, 1}
 }
 func (m *OutputView_Opaque) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1593,7 +1843,7 @@ func (m *OutputPlan) Reset()         { *m = OutputPlan{} }
 func (m *OutputPlan) String() string { return proto.CompactTextString(m) }
 func (*OutputPlan) ProtoMessage()    {}
 func (*OutputPlan) Descriptor() ([]byte, []int) {
-	return fileDescriptor_26a9f446de1cd73c, []int{21}
+	return fileDescriptor_26a9f446de1cd73c, []int{22}
 }
 func (m *OutputPlan) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1674,7 +1924,7 @@ func (m *AssetMetadataByIdRequest) Reset()         { *m = AssetMetadataByIdReque
 func (m *AssetMetadataByIdRequest) String() string { return proto.CompactTextString(m) }
 func (*AssetMetadataByIdRequest) ProtoMessage()    {}
 func (*AssetMetadataByIdRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_26a9f446de1cd73c, []int{22}
+	return fileDescriptor_26a9f446de1cd73c, []int{23}
 }
 func (m *AssetMetadataByIdRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1721,7 +1971,7 @@ func (m *AssetMetadataByIdResponse) Reset()         { *m = AssetMetadataByIdResp
 func (m *AssetMetadataByIdResponse) String() string { return proto.CompactTextString(m) }
 func (*AssetMetadataByIdResponse) ProtoMessage()    {}
 func (*AssetMetadataByIdResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_26a9f446de1cd73c, []int{23}
+	return fileDescriptor_26a9f446de1cd73c, []int{24}
 }
 func (m *AssetMetadataByIdResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1768,7 +2018,7 @@ func (m *AssetMetadataByIdsRequest) Reset()         { *m = AssetMetadataByIdsReq
 func (m *AssetMetadataByIdsRequest) String() string { return proto.CompactTextString(m) }
 func (*AssetMetadataByIdsRequest) ProtoMessage()    {}
 func (*AssetMetadataByIdsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_26a9f446de1cd73c, []int{24}
+	return fileDescriptor_26a9f446de1cd73c, []int{25}
 }
 func (m *AssetMetadataByIdsRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1813,7 +2063,7 @@ func (m *AssetMetadataByIdsResponse) Reset()         { *m = AssetMetadataByIdsRe
 func (m *AssetMetadataByIdsResponse) String() string { return proto.CompactTextString(m) }
 func (*AssetMetadataByIdsResponse) ProtoMessage()    {}
 func (*AssetMetadataByIdsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_26a9f446de1cd73c, []int{25}
+	return fileDescriptor_26a9f446de1cd73c, []int{26}
 }
 func (m *AssetMetadataByIdsResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1854,6 +2104,10 @@ func init() {
 	proto.RegisterType((*GenesisContent)(nil), "penumbra.core.component.shielded_pool.v1.GenesisContent")
 	proto.RegisterType((*GenesisContent_Allocation)(nil), "penumbra.core.component.shielded_pool.v1.GenesisContent.Allocation")
 	proto.RegisterType((*FmdMetaParameters)(nil), "penumbra.core.component.shielded_pool.v1.FmdMetaParameters")
+	proto.RegisterType((*FmdMetaParameters_AlgorithmSlidingWindow)(nil), "penumbra.core.component.shielded_pool.v1.FmdMetaParameters.AlgorithmSlidingWindow")
+	proto.RegisterType((*FmdMetaParametersAlgorithmState)(nil), "penumbra.core.component.shielded_pool.v1.FmdMetaParametersAlgorithmState")
+	proto.RegisterType((*FmdMetaParametersAlgorithmState_FixedState)(nil), "penumbra.core.component.shielded_pool.v1.FmdMetaParametersAlgorithmState.FixedState")
+	proto.RegisterType((*FmdMetaParametersAlgorithmState_SlidingWindowState)(nil), "penumbra.core.component.shielded_pool.v1.FmdMetaParametersAlgorithmState.SlidingWindowState")
 	proto.RegisterType((*FmdParameters)(nil), "penumbra.core.component.shielded_pool.v1.FmdParameters")
 	proto.RegisterType((*Note)(nil), "penumbra.core.component.shielded_pool.v1.Note")
 	proto.RegisterType((*NoteView)(nil), "penumbra.core.component.shielded_pool.v1.NoteView")
@@ -1888,119 +2142,131 @@ func init() {
 }
 
 var fileDescriptor_26a9f446de1cd73c = []byte{
-	// 1783 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x58, 0xcd, 0x6f, 0x1b, 0xc7,
-	0x15, 0xd7, 0x52, 0x94, 0x6c, 0x3f, 0x7e, 0xd8, 0x1e, 0x18, 0xad, 0x4a, 0xb4, 0xac, 0xbb, 0x8d,
-	0x1d, 0x05, 0x29, 0xc8, 0x50, 0x72, 0xe2, 0x54, 0xf6, 0xa1, 0x22, 0x13, 0x4b, 0x86, 0xea, 0x88,
-	0x1d, 0x25, 0xb2, 0x61, 0x08, 0x58, 0x0c, 0x77, 0x87, 0xe2, 0x42, 0xdc, 0x9d, 0xcd, 0xcc, 0x90,
-	0x16, 0x7b, 0x0a, 0x7a, 0x68, 0x0f, 0xbd, 0x14, 0x01, 0x8a, 0xf6, 0xd0, 0x4b, 0x7a, 0xec, 0xb9,
-	0x7f, 0x44, 0xd1, 0x53, 0x7a, 0xeb, 0xad, 0x85, 0xdd, 0x5e, 0x7a, 0xe9, 0xad, 0xe7, 0x62, 0x66,
-	0x67, 0x97, 0x5c, 0x4a, 0x14, 0x48, 0x5b, 0x40, 0x2e, 0xd2, 0xce, 0x9b, 0xdf, 0xfb, 0xbd, 0xcf,
-	0x79, 0x3b, 0x4b, 0x78, 0x18, 0xd1, 0x70, 0x10, 0x74, 0x38, 0xa9, 0xbb, 0x8c, 0xd3, 0xba, 0xcb,
-	0x82, 0x88, 0x85, 0x34, 0x94, 0x75, 0xd1, 0xf3, 0x69, 0xdf, 0xa3, 0x9e, 0x13, 0x31, 0xd6, 0xaf,
-	0x0f, 0x1b, 0x59, 0x41, 0x2d, 0xe2, 0x4c, 0x32, 0xb4, 0x9e, 0x68, 0xd7, 0x94, 0x76, 0x2d, 0xd5,
-	0xae, 0x65, 0xc1, 0xc3, 0x46, 0xc5, 0xce, 0xda, 0x21, 0x42, 0x50, 0xa9, 0x58, 0xf5, 0x43, 0xcc,
-	0x56, 0x59, 0x9f, 0xe9, 0x8b, 0xab, 0xb1, 0xc2, 0x4d, 0x90, 0xb7, 0xb3, 0xc8, 0x13, 0x3a, 0x12,
-	0x0a, 0xa0, 0xfe, 0x1b, 0x44, 0x35, 0x8b, 0x08, 0x07, 0x81, 0x02, 0x84, 0x83, 0xc0, 0xec, 0xbf,
-	0x95, 0xdd, 0x97, 0xa7, 0x3d, 0x22, 0x7a, 0x0a, 0x12, 0x3f, 0x19, 0xd4, 0xc6, 0x18, 0xc5, 0x47,
-	0x91, 0x64, 0x75, 0x8f, 0xba, 0xa4, 0xbb, 0x79, 0xff, 0xbe, 0xd3, 0x0d, 0x3c, 0x85, 0x9e, 0x5c,
-	0x1b, 0x9d, 0x7b, 0x33, 0x75, 0xb8, 0x27, 0x48, 0x46, 0x49, 0x09, 0xce, 0x46, 0x14, 0x6b, 0xc9,
-	0x38, 0x66, 0x99, 0xc4, 0x6c, 0xff, 0xcb, 0x82, 0x6f, 0x1d, 0x98, 0xb4, 0xb6, 0x19, 0xeb, 0xb7,
-	0x09, 0x27, 0x01, 0x95, 0x94, 0x0b, 0x44, 0xe1, 0x46, 0xd7, 0x3f, 0xa5, 0x9e, 0xf2, 0xc2, 0x89,
-	0x94, 0x5c, 0xac, 0x59, 0xb7, 0xad, 0xf5, 0xc2, 0xc6, 0xfd, 0xda, 0xbc, 0x15, 0xaa, 0x3d, 0x0a,
-	0xbc, 0x31, 0x65, 0x33, 0xb7, 0x66, 0xe1, 0xb2, 0x26, 0x4d, 0xe4, 0x02, 0xb9, 0x70, 0x5d, 0x19,
-	0x08, 0xa8, 0x24, 0x89, 0x95, 0x9c, 0xb6, 0xf2, 0x60, 0x21, 0x2b, 0x4f, 0xa8, 0x24, 0x63, 0x4b,
-	0xb8, 0xd4, 0x9d, 0x10, 0x09, 0xfb, 0x8b, 0x65, 0x28, 0xef, 0xd0, 0x90, 0x0a, 0x5f, 0xb4, 0x58,
-	0x28, 0x69, 0x28, 0x11, 0x87, 0x5b, 0x19, 0x9e, 0x6c, 0x88, 0x3f, 0x99, 0xdf, 0xf8, 0xf9, 0xe9,
-	0xc3, 0x48, 0x4c, 0xcb, 0x55, 0x4a, 0x0b, 0xa4, 0xdf, 0x67, 0x2e, 0x91, 0x3e, 0x0b, 0xc5, 0xda,
-	0xf2, 0xed, 0xe5, 0xf5, 0xc2, 0x46, 0x6b, 0x7e, 0x53, 0xd9, 0x10, 0x6a, 0xdb, 0x29, 0x17, 0x9e,
-	0xe4, 0xad, 0x7c, 0x69, 0x01, 0x8c, 0xf7, 0xd0, 0x3d, 0x58, 0x25, 0x01, 0x1b, 0x84, 0xd2, 0xc4,
-	0xf6, 0xdd, 0x29, 0x83, 0xaa, 0x7f, 0x87, 0x8d, 0xda, 0xb6, 0xc6, 0x60, 0x83, 0x45, 0xb7, 0x60,
-	0xc5, 0xa3, 0x21, 0x0b, 0x74, 0x35, 0xae, 0xe1, 0x78, 0x81, 0x3e, 0x84, 0x2b, 0xc4, 0xf3, 0x38,
-	0x15, 0xca, 0x7b, 0x45, 0x56, 0x9d, 0x22, 0xd3, 0xa7, 0x45, 0xb1, 0xc5, 0x28, 0x9c, 0xc0, 0xed,
-	0x5f, 0x5b, 0x70, 0xf3, 0x4c, 0x9d, 0xd0, 0xfb, 0xf0, 0x6d, 0x55, 0xfd, 0x63, 0x4e, 0x5c, 0xea,
-	0x44, 0x94, 0xfb, 0xcc, 0x73, 0x3a, 0x7d, 0xe6, 0x9e, 0xc4, 0x85, 0xc8, 0xe3, 0x5b, 0xdd, 0xc0,
-	0xdb, 0x51, 0xbb, 0x6d, 0xbd, 0xd9, 0xd4, 0x7b, 0x68, 0x03, 0x6e, 0xc5, 0xbd, 0x19, 0x71, 0xea,
-	0xfa, 0xc2, 0x67, 0xa1, 0xd3, 0xf1, 0x65, 0xdc, 0x39, 0xa5, 0xdd, 0x25, 0x8c, 0xf4, 0x6e, 0x3b,
-	0xd9, 0x6c, 0xfa, 0x52, 0x34, 0x0b, 0x70, 0x8d, 0xf4, 0x8f, 0x19, 0xf7, 0x65, 0x2f, 0xb0, 0x5d,
-	0x28, 0x65, 0x5a, 0x13, 0xdd, 0x81, 0xf2, 0x14, 0x97, 0xb2, 0x5f, 0xc2, 0xa5, 0x68, 0x92, 0x04,
-	0xbd, 0x0b, 0x88, 0x08, 0x87, 0x75, 0x63, 0x27, 0x9d, 0x1e, 0xf5, 0x8f, 0x7b, 0x52, 0x9b, 0xcd,
-	0xe3, 0xeb, 0x44, 0xec, 0x77, 0xb5, 0x83, 0xbb, 0x5a, 0xac, 0x42, 0xce, 0x7f, 0xc2, 0x24, 0x45,
-	0x9b, 0xb0, 0x32, 0x24, 0xfd, 0x01, 0x35, 0x05, 0xf8, 0xde, 0x54, 0xce, 0xe2, 0x71, 0x35, 0x6c,
-	0xd4, 0x0e, 0x15, 0x08, 0xc7, 0x58, 0x55, 0x00, 0x2e, 0x28, 0xf5, 0x34, 0x7b, 0x11, 0xc7, 0x8b,
-	0x37, 0x28, 0xc0, 0xef, 0x2c, 0xb8, 0xaa, 0xbc, 0x39, 0xf4, 0xe9, 0x0b, 0x74, 0x3f, 0xeb, 0xd1,
-	0x0f, 0x2e, 0xf4, 0x48, 0x69, 0x5c, 0xec, 0xd5, 0xc3, 0x69, 0xaf, 0xec, 0x8b, 0xbd, 0xd2, 0x8c,
-	0xa9, 0x67, 0x77, 0xa1, 0xac, 0x1c, 0x6b, 0xf9, 0x51, 0x8f, 0x72, 0x49, 0x4f, 0x75, 0xf3, 0xf9,
-	0x61, 0x48, 0xb9, 0x76, 0xaf, 0x88, 0xe3, 0x85, 0xfd, 0x6f, 0x0b, 0x0a, 0x0a, 0xd8, 0x26, 0xa3,
-	0x3e, 0x23, 0x1e, 0x6a, 0xc3, 0xf5, 0x90, 0x49, 0xea, 0xb8, 0x2c, 0x08, 0x7c, 0x19, 0xd0, 0xb4,
-	0xc3, 0xdf, 0x9e, 0xb0, 0xae, 0x07, 0x5f, 0x4d, 0x4d, 0x3c, 0x75, 0x56, 0x25, 0x91, 0xb4, 0x95,
-	0xc2, 0x71, 0x59, 0xe9, 0x8f, 0xd7, 0xe8, 0x87, 0x50, 0xa2, 0x51, 0x8f, 0x06, 0x94, 0x93, 0xbe,
-	0x73, 0x42, 0x47, 0x26, 0xca, 0x62, 0x2a, 0xdc, 0xa3, 0x23, 0xe4, 0x40, 0x99, 0x86, 0x9a, 0x97,
-	0x7a, 0x8e, 0x22, 0x30, 0x31, 0x7f, 0x38, 0xff, 0x41, 0xce, 0x86, 0x8b, 0x4b, 0x29, 0x9f, 0xda,
-	0xb0, 0xef, 0x40, 0xe9, 0xf9, 0xde, 0xfe, 0x40, 0x46, 0x03, 0xd9, 0xe6, 0x8c, 0x75, 0x67, 0xa4,
-	0xe3, 0x2d, 0x28, 0x3e, 0xdf, 0x3b, 0x88, 0x68, 0xe8, 0x5d, 0x84, 0xda, 0x80, 0xca, 0xf3, 0xbd,
-	0x4f, 0x06, 0xfd, 0xbe, 0xdf, 0xf5, 0x29, 0xff, 0x88, 0x72, 0x7f, 0xa8, 0xc7, 0xc2, 0x45, 0x3a,
-	0xff, 0xb5, 0x60, 0x45, 0x13, 0xa3, 0x1d, 0xc8, 0x77, 0x98, 0x37, 0x32, 0x79, 0xdd, 0x5c, 0x60,
-	0x2a, 0x2a, 0xf5, 0x26, 0xf3, 0x46, 0x58, 0x13, 0xa0, 0x7d, 0xb8, 0x4a, 0x06, 0xb2, 0xe7, 0x08,
-	0xff, 0xd8, 0xcc, 0xf7, 0x7b, 0x67, 0x8a, 0x94, 0x7d, 0x85, 0x25, 0x24, 0xdb, 0x03, 0xd9, 0x3b,
-	0xf0, 0x8f, 0x43, 0x22, 0x07, 0x9c, 0xe2, 0x2b, 0x24, 0x5e, 0xa2, 0x9f, 0xc2, 0x4a, 0xa4, 0x42,
-	0x30, 0xc9, 0xff, 0x60, 0x7e, 0xd7, 0x26, 0x93, 0x86, 0x63, 0x12, 0xfb, 0x33, 0x80, 0x8f, 0x87,
-	0x34, 0x94, 0x49, 0xd4, 0xd7, 0xc2, 0x24, 0x63, 0x26, 0xf4, 0x77, 0x66, 0xf3, 0xc7, 0xad, 0x95,
-	0xa6, 0x18, 0x8f, 0x75, 0x6d, 0x07, 0x0a, 0x9a, 0x36, 0x2e, 0xe6, 0xe5, 0x37, 0xac, 0xfd, 0x2b,
-	0x0b, 0x90, 0xb6, 0xd0, 0xe4, 0x8c, 0x78, 0x2e, 0x11, 0xb2, 0xa5, 0x4e, 0xe9, 0x8f, 0x21, 0xef,
-	0x8e, 0x4f, 0xf7, 0x9d, 0xd9, 0x99, 0x56, 0x37, 0x8c, 0x61, 0xa3, 0xa6, 0x94, 0xb0, 0x56, 0x41,
-	0x1f, 0x40, 0x4e, 0x9e, 0x9a, 0x12, 0xdd, 0x9d, 0x0a, 0xda, 0x5c, 0x63, 0x86, 0x8d, 0xda, 0xa7,
-	0x9c, 0x84, 0x82, 0xb8, 0xaa, 0x91, 0x1e, 0x7b, 0x38, 0x27, 0x4f, 0xed, 0xff, 0x59, 0x70, 0x2d,
-	0x2d, 0x3a, 0x7a, 0x06, 0xa8, 0x43, 0xfa, 0x24, 0x74, 0xcf, 0x09, 0xf6, 0x9d, 0x59, 0xc3, 0xa6,
-	0x19, 0x6b, 0x4c, 0x84, 0x7b, 0xb3, 0x33, 0x2d, 0xca, 0xd6, 0x66, 0xf5, 0xf5, 0x6b, 0x83, 0x1e,
-	0x41, 0x8e, 0x9f, 0xac, 0xe5, 0xcf, 0x74, 0xcf, 0x45, 0xbd, 0x78, 0x48, 0xb9, 0xdf, 0xf5, 0xe3,
-	0xf7, 0xea, 0x1e, 0x1d, 0xe1, 0x1c, 0x3f, 0xb1, 0xff, 0xbc, 0x6c, 0x02, 0xd7, 0x83, 0xf5, 0x29,
-	0x5c, 0x19, 0xfa, 0xc2, 0xef, 0xf4, 0x93, 0xe4, 0x3f, 0x58, 0xf0, 0xcc, 0x28, 0x96, 0xda, 0x61,
-	0x4c, 0xb1, 0xbb, 0x84, 0x13, 0x36, 0xf4, 0x29, 0xac, 0xb2, 0x88, 0x7c, 0x3e, 0xa0, 0xa6, 0x36,
-	0x5b, 0xaf, 0xc3, 0xbb, 0xaf, 0x19, 0x76, 0x97, 0xb0, 0xe1, 0xaa, 0xfc, 0xde, 0x82, 0x2b, 0xc6,
-	0x18, 0xfa, 0x18, 0x56, 0x84, 0x42, 0x1a, 0xc7, 0xeb, 0x0b, 0x1a, 0xc0, 0xb1, 0x36, 0x7a, 0x04,
-	0x79, 0x3d, 0x14, 0x63, 0x37, 0x37, 0x16, 0x1b, 0x8a, 0xfa, 0xc5, 0xa0, 0xf5, 0x2b, 0xfb, 0xb0,
-	0x1a, 0xbb, 0x7b, 0x49, 0x8e, 0x35, 0x8b, 0x00, 0xfa, 0xc1, 0x19, 0xfa, 0xf4, 0x85, 0xfd, 0xcb,
-	0x9c, 0x29, 0x5b, 0xbb, 0x4f, 0x42, 0xd4, 0x34, 0x4e, 0xc7, 0x16, 0x6a, 0x8b, 0x39, 0x1d, 0x3b,
-	0x8c, 0x2a, 0x70, 0x35, 0x62, 0xc2, 0x57, 0xbd, 0x61, 0x6e, 0x04, 0xe9, 0x1a, 0x55, 0x01, 0x38,
-	0x09, 0x3d, 0x16, 0xf8, 0x3f, 0xa7, 0x5c, 0x8f, 0xac, 0x22, 0x9e, 0x90, 0xa8, 0xeb, 0x87, 0x7e,
-	0xbf, 0x3a, 0x9d, 0xbe, 0x1f, 0x7a, 0x7e, 0x78, 0xac, 0x1b, 0xb3, 0x88, 0x4b, 0x5a, 0xda, 0x34,
-	0x42, 0xb4, 0x0e, 0x37, 0xf4, 0xbc, 0x4a, 0x61, 0x0e, 0x5f, 0x5b, 0xd1, 0xc0, 0xb2, 0x96, 0x27,
-	0x40, 0x7c, 0x0e, 0x52, 0xe8, 0xd3, 0x32, 0x8d, 0x3c, 0xb0, 0xbf, 0xb2, 0x60, 0xd5, 0xcc, 0xa7,
-	0xdd, 0xcc, 0xb4, 0xbf, 0x37, 0x7f, 0x16, 0x62, 0xfd, 0x89, 0x71, 0xff, 0x24, 0x99, 0xce, 0xb9,
-	0x45, 0xbf, 0x18, 0x32, 0x6f, 0xbe, 0x64, 0x3c, 0x7f, 0x99, 0x03, 0x18, 0xdb, 0x40, 0xcf, 0xa0,
-	0xa8, 0xe7, 0x68, 0x14, 0x5f, 0x04, 0x8c, 0xbf, 0xef, 0x2f, 0x56, 0x35, 0x73, 0x8b, 0xc0, 0x85,
-	0x70, 0xe2, 0x4a, 0x71, 0xfe, 0xdc, 0xca, 0x5d, 0xc2, 0xdc, 0x5a, 0x87, 0x1b, 0x2f, 0x38, 0x89,
-	0x22, 0xaa, 0xbe, 0x75, 0x02, 0xa6, 0x6f, 0x17, 0x71, 0x1f, 0x94, 0x8d, 0xfc, 0x09, 0x0d, 0x98,
-	0xba, 0x5f, 0xdc, 0x85, 0xeb, 0x6c, 0x78, 0xe2, 0x24, 0x68, 0x05, 0x34, 0xcd, 0xc0, 0x86, 0x27,
-	0x4f, 0x63, 0xe9, 0x1e, 0x1d, 0xd9, 0xbf, 0xc8, 0x27, 0x49, 0xd1, 0x93, 0xe7, 0xd9, 0xf4, 0xe4,
-	0x79, 0xb8, 0x68, 0xfd, 0x66, 0x8d, 0x9e, 0xcf, 0xa6, 0x46, 0xcf, 0x83, 0xd7, 0x22, 0x3e, 0x33,
-	0x7b, 0xfe, 0x31, 0x31, 0x7b, 0x76, 0x61, 0x95, 0x69, 0xa8, 0xf1, 0xfd, 0xbd, 0x45, 0x4d, 0x60,
-	0xa3, 0x7f, 0x59, 0xe3, 0x07, 0x35, 0xa1, 0x60, 0xda, 0x2b, 0x2d, 0xd5, 0xd9, 0x7b, 0x72, 0x72,
-	0xad, 0x35, 0xed, 0xa3, 0x5e, 0x09, 0x10, 0xa5, 0xcf, 0x15, 0x9c, 0x8e, 0xb0, 0x4b, 0x8b, 0xaf,
-	0x59, 0x82, 0x42, 0xfc, 0x14, 0x8f, 0xb1, 0xdf, 0xa6, 0x27, 0x43, 0xcf, 0xb1, 0xd7, 0xfa, 0xd2,
-	0xd8, 0x86, 0xa2, 0x47, 0x85, 0x74, 0x92, 0x2b, 0x7c, 0x6e, 0xae, 0x0f, 0x8b, 0x82, 0xd2, 0x31,
-	0x8b, 0xf1, 0x67, 0xc1, 0xf2, 0xe4, 0x67, 0xc1, 0x37, 0x38, 0xd5, 0x0e, 0x61, 0x6d, 0x5b, 0x05,
-	0xab, 0xbe, 0x37, 0x3d, 0x22, 0x49, 0x73, 0xf4, 0xd8, 0xc3, 0xf4, 0xf3, 0x01, 0x15, 0x12, 0x6d,
-	0xc1, 0x55, 0x9d, 0x08, 0xc7, 0xf7, 0x4c, 0xac, 0xdf, 0x9f, 0x95, 0x27, 0xcd, 0xf1, 0xd8, 0xc3,
-	0x57, 0x48, 0xfc, 0x60, 0x7b, 0xf0, 0x9d, 0x73, 0x78, 0x45, 0xc4, 0x42, 0x41, 0xd1, 0x0e, 0x94,
-	0xf5, 0x67, 0xb2, 0xfe, 0x35, 0x43, 0xed, 0x9a, 0x32, 0xdc, 0x9e, 0x45, 0x9f, 0xb0, 0xe0, 0x92,
-	0xd6, 0x4b, 0x96, 0xf6, 0xd3, 0x73, 0xac, 0x88, 0xf3, 0xdc, 0xb7, 0xf4, 0x4f, 0x08, 0xf3, 0xbb,
-	0x4f, 0xa1, 0x72, 0x1e, 0xf1, 0x25, 0xfb, 0xbf, 0xf1, 0xb7, 0x1c, 0x14, 0x7f, 0x36, 0xa0, 0x7c,
-	0x74, 0x40, 0xf9, 0xd0, 0x77, 0x29, 0xfa, 0x83, 0x05, 0x37, 0xcf, 0x18, 0x46, 0xcd, 0xf9, 0x4f,
-	0xc1, 0xac, 0x62, 0x56, 0x5a, 0x6f, 0xc4, 0x61, 0x02, 0xff, 0xca, 0x02, 0x74, 0x36, 0x2f, 0xe8,
-	0x4d, 0xb8, 0x93, 0x72, 0x55, 0x3e, 0x7a, 0x33, 0x92, 0xd8, 0xc3, 0xf7, 0xac, 0xe6, 0x17, 0xcb,
-	0x7f, 0x79, 0x59, 0xb5, 0xbe, 0x7e, 0x59, 0xb5, 0xfe, 0xf9, 0xb2, 0x6a, 0xfd, 0xe6, 0x55, 0x75,
-	0xe9, 0xeb, 0x57, 0xd5, 0xa5, 0xbf, 0xbf, 0xaa, 0x2e, 0xc1, 0x8f, 0x5c, 0x16, 0xcc, 0x6d, 0xa5,
-	0x79, 0x33, 0xf3, 0x8b, 0x15, 0x67, 0x92, 0xb5, 0xad, 0xe7, 0xde, 0xb1, 0x2f, 0x7b, 0x83, 0x8e,
-	0xd2, 0xab, 0xbb, 0x4c, 0x04, 0x4c, 0xd4, 0x39, 0xed, 0x93, 0x11, 0xe5, 0xf5, 0xe1, 0x46, 0xfa,
-	0xe8, 0xf6, 0x88, 0x1f, 0x8a, 0xfa, 0xbc, 0x3f, 0xef, 0x3e, 0xc8, 0x08, 0x86, 0x8d, 0x3f, 0xe6,
-	0xf2, 0xed, 0x56, 0xeb, 0xe0, 0x4f, 0xb9, 0xb7, 0xdb, 0x89, 0xb3, 0x2d, 0xe5, 0x6c, 0x2b, 0x75,
-	0x76, 0xd2, 0xb5, 0xda, 0x61, 0xe3, 0xaf, 0x63, 0xe4, 0x91, 0x42, 0x1e, 0xa5, 0xc8, 0xa3, 0x49,
-	0xe4, 0xd1, 0x61, 0xe3, 0x65, 0x6e, 0x73, 0x4e, 0xe4, 0xd1, 0x4e, 0xbb, 0x99, 0xe4, 0xf8, 0x3f,
-	0xb9, 0x77, 0x13, 0xad, 0xad, 0x2d, 0xa5, 0xa6, 0xfe, 0x1a, 0xbd, 0xad, 0xad, 0x49, 0xc5, 0xad,
-	0xad, 0xc3, 0x46, 0x67, 0x55, 0xff, 0x68, 0xba, 0xf9, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x41,
-	0xd6, 0xa7, 0x98, 0xe0, 0x16, 0x00, 0x00,
+	// 1981 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x59, 0xcf, 0x73, 0x1b, 0x49,
+	0x15, 0xf6, 0xc8, 0xbf, 0x92, 0x67, 0xc9, 0xd9, 0x34, 0x21, 0x18, 0x01, 0xde, 0x30, 0x6c, 0xb2,
+	0xde, 0x5a, 0x4a, 0x5e, 0x39, 0xd9, 0xcd, 0xe2, 0xe4, 0x80, 0xa5, 0x6c, 0xe2, 0x60, 0xb2, 0x11,
+	0xed, 0xc4, 0x49, 0xa5, 0x5c, 0x35, 0xd5, 0x9a, 0x69, 0x59, 0x53, 0x9e, 0x99, 0x9e, 0x9d, 0x6e,
+	0xc9, 0x16, 0x5c, 0xb6, 0xa8, 0x02, 0x0e, 0x5c, 0x60, 0xab, 0x28, 0x38, 0xec, 0x65, 0x39, 0x72,
+	0xe6, 0x8f, 0xa0, 0x38, 0x2d, 0x37, 0x6e, 0x50, 0x09, 0x5c, 0xb8, 0x70, 0xe3, 0xc0, 0x89, 0xea,
+	0x1f, 0x33, 0xd2, 0x48, 0x96, 0x4b, 0x8a, 0x5d, 0xc5, 0x25, 0x99, 0xe9, 0xfe, 0xde, 0xf7, 0xbe,
+	0xf7, 0x5e, 0xf7, 0xeb, 0x1e, 0x19, 0xee, 0xc6, 0x34, 0xea, 0x84, 0xcd, 0x84, 0xac, 0xbb, 0x2c,
+	0xa1, 0xeb, 0x2e, 0x0b, 0x63, 0x16, 0xd1, 0x48, 0xac, 0xf3, 0xb6, 0x4f, 0x03, 0x8f, 0x7a, 0x4e,
+	0xcc, 0x58, 0xb0, 0xde, 0xad, 0xe6, 0x07, 0x2a, 0x71, 0xc2, 0x04, 0x43, 0x6b, 0xa9, 0x75, 0x45,
+	0x5a, 0x57, 0x32, 0xeb, 0x4a, 0x1e, 0xdc, 0xad, 0x96, 0xed, 0xbc, 0x1f, 0xc2, 0x39, 0x15, 0x92,
+	0x55, 0x3d, 0x68, 0xb6, 0xf2, 0xda, 0x58, 0x2d, 0xae, 0xc2, 0x72, 0x37, 0x45, 0x5e, 0xcb, 0x23,
+	0x0f, 0x69, 0x8f, 0x4b, 0x80, 0xfc, 0xdf, 0x20, 0x56, 0xf3, 0x88, 0xa8, 0x13, 0x4a, 0x40, 0xd4,
+	0x09, 0xcd, 0xfc, 0x5b, 0xf9, 0x79, 0x71, 0xdc, 0x26, 0xbc, 0x2d, 0x21, 0xfa, 0xc9, 0xa0, 0x36,
+	0xfa, 0xa8, 0xa4, 0x17, 0x0b, 0xb6, 0xee, 0x51, 0x97, 0xb4, 0x6e, 0xde, 0xbe, 0xed, 0xb4, 0x42,
+	0x4f, 0xa2, 0x07, 0xdf, 0x8d, 0xcd, 0xad, 0xb1, 0x36, 0x89, 0xc7, 0x49, 0xce, 0x48, 0x0e, 0x8c,
+	0x46, 0xa4, 0xad, 0x84, 0x8e, 0x59, 0xa4, 0x31, 0xdb, 0xff, 0xb0, 0xe0, 0xea, 0xae, 0x49, 0x6b,
+	0x83, 0xb1, 0xa0, 0x41, 0x12, 0x12, 0x52, 0x41, 0x13, 0x8e, 0x28, 0xbc, 0xd1, 0xf2, 0x8f, 0xa9,
+	0x27, 0x55, 0x38, 0xb1, 0x1c, 0xe7, 0x2b, 0xd6, 0x35, 0x6b, 0x6d, 0x69, 0xe3, 0x76, 0x65, 0xd2,
+	0x0a, 0x55, 0xee, 0x87, 0x5e, 0x9f, 0xb2, 0x56, 0x58, 0xb1, 0xf0, 0xb2, 0x22, 0x4d, 0xc7, 0x39,
+	0x72, 0xe1, 0x92, 0x74, 0x10, 0x52, 0x41, 0x52, 0x2f, 0x05, 0xe5, 0xe5, 0xce, 0x54, 0x5e, 0x1e,
+	0x51, 0x41, 0xfa, 0x9e, 0x70, 0xa9, 0x35, 0x30, 0xc4, 0xed, 0x4f, 0x67, 0x61, 0xf9, 0x01, 0x8d,
+	0x28, 0xf7, 0x79, 0x9d, 0x45, 0x82, 0x46, 0x02, 0x25, 0x70, 0x25, 0xc7, 0x93, 0x0f, 0xf1, 0xfb,
+	0x93, 0x3b, 0x3f, 0x39, 0x7d, 0x18, 0xf1, 0xe1, 0x71, 0x99, 0xd2, 0x25, 0x12, 0x04, 0xcc, 0x25,
+	0xc2, 0x67, 0x11, 0x5f, 0x99, 0xbd, 0x36, 0xbb, 0xb6, 0xb4, 0x51, 0x9f, 0xdc, 0x55, 0x3e, 0x84,
+	0xca, 0x56, 0xc6, 0x85, 0x07, 0x79, 0xcb, 0x9f, 0x59, 0x00, 0xfd, 0x39, 0x74, 0x0b, 0x16, 0x48,
+	0xc8, 0x3a, 0x91, 0x30, 0xb1, 0x7d, 0x73, 0xc8, 0xa1, 0x5c, 0xbf, 0xdd, 0x6a, 0x65, 0x4b, 0x61,
+	0xb0, 0xc1, 0xa2, 0x2b, 0x30, 0xef, 0xd1, 0x88, 0x85, 0xaa, 0x1a, 0x17, 0xb1, 0x7e, 0x41, 0x1f,
+	0xc2, 0x22, 0xf1, 0xbc, 0x84, 0x72, 0xa9, 0x5e, 0x92, 0xad, 0x0e, 0x91, 0xa9, 0xdd, 0x22, 0xd9,
+	0x34, 0x0a, 0xa7, 0x70, 0xfb, 0xf3, 0x59, 0xb8, 0x3c, 0x52, 0x27, 0xf4, 0x3e, 0x7c, 0x4d, 0x56,
+	0xff, 0x20, 0x21, 0x2e, 0x75, 0x62, 0x9a, 0xf8, 0xcc, 0x73, 0x9a, 0x01, 0x73, 0x0f, 0x75, 0x21,
+	0xe6, 0xf0, 0x95, 0x56, 0xe8, 0x3d, 0x90, 0xb3, 0x0d, 0x35, 0x59, 0x53, 0x73, 0x68, 0x03, 0xae,
+	0xe8, 0xb5, 0x19, 0x27, 0xd4, 0xf5, 0xb9, 0xcf, 0x22, 0xa7, 0xe9, 0x0b, 0xbd, 0x72, 0x4a, 0xdb,
+	0x33, 0x18, 0xa9, 0xd9, 0x46, 0x3a, 0x59, 0xf3, 0x05, 0x47, 0x3f, 0x81, 0x65, 0x1e, 0xf8, 0x9e,
+	0x1f, 0x1d, 0x38, 0x47, 0x7e, 0xe4, 0xb1, 0x23, 0x13, 0x01, 0x3e, 0xc3, 0x3a, 0xab, 0x6c, 0x05,
+	0x07, 0x2c, 0xf1, 0x45, 0x3b, 0xdc, 0xd5, 0xd4, 0xcf, 0x14, 0xf3, 0xf6, 0x0c, 0x2e, 0xf1, 0xc1,
+	0x81, 0xf2, 0xaf, 0x2d, 0xb8, 0x7a, 0x32, 0x16, 0x6d, 0xc0, 0x57, 0xb5, 0x1e, 0xa7, 0x13, 0x7b,
+	0x44, 0xa4, 0x69, 0xd0, 0x09, 0x28, 0xe1, 0xaf, 0xe8, 0xc9, 0xa7, 0x6a, 0x4e, 0x27, 0x81, 0xa3,
+	0x3a, 0xac, 0x0a, 0x92, 0x1c, 0x50, 0x41, 0x3d, 0xc7, 0xa3, 0x82, 0xba, 0xaa, 0xf0, 0xd2, 0x32,
+	0x8d, 0x4d, 0x65, 0x02, 0x7f, 0x23, 0x45, 0xdd, 0xcb, 0x40, 0x0d, 0x9a, 0x68, 0xc7, 0xb5, 0x25,
+	0xb8, 0x48, 0x52, 0x49, 0xf6, 0x7f, 0x0b, 0xf0, 0xe6, 0x48, 0x78, 0x7d, 0xc5, 0x82, 0x08, 0x8a,
+	0x02, 0x98, 0x57, 0x79, 0x35, 0xeb, 0xe8, 0xc9, 0x19, 0x12, 0x97, 0x67, 0xae, 0xdc, 0x97, 0xb4,
+	0xea, 0x71, 0x7b, 0x06, 0x6b, 0x27, 0xe8, 0x67, 0xd6, 0x48, 0xc1, 0x74, 0x63, 0xd8, 0x3f, 0x3f,
+	0xbf, 0xb9, 0x4a, 0xa4, 0xfe, 0x87, 0x4a, 0x57, 0x04, 0xe8, 0xcb, 0x2b, 0xff, 0x00, 0xd0, 0xa8,
+	0x11, 0xba, 0x05, 0x57, 0x49, 0x1c, 0x27, 0xec, 0xd8, 0x0f, 0x65, 0x05, 0xdd, 0xa0, 0x43, 0x1d,
+	0x37, 0xdb, 0x72, 0x25, 0x7c, 0x65, 0x60, 0xb6, 0x1e, 0x74, 0x68, 0x5d, 0xce, 0xd5, 0x16, 0x61,
+	0x9e, 0x4b, 0x73, 0xdb, 0x85, 0x52, 0xae, 0x51, 0xa2, 0xeb, 0xb0, 0x3c, 0xb4, 0xb2, 0x35, 0x4f,
+	0x29, 0xce, 0x2d, 0xe9, 0x77, 0x01, 0x11, 0xee, 0xb0, 0x96, 0xde, 0x32, 0x4e, 0x9b, 0xfa, 0x07,
+	0x6d, 0xa1, 0xb2, 0x34, 0x87, 0x2f, 0x11, 0xfe, 0xb8, 0xa5, 0xb6, 0xcb, 0xb6, 0x1a, 0xb6, 0x7f,
+	0x69, 0xc1, 0xdc, 0xc7, 0x4c, 0x50, 0x74, 0x13, 0xe6, 0xbb, 0x24, 0xe8, 0x50, 0x53, 0xc6, 0x6f,
+	0x0d, 0xa5, 0x53, 0x1f, 0x9e, 0xdd, 0x6a, 0x65, 0x4f, 0x82, 0xb0, 0xc6, 0xca, 0x76, 0x90, 0x70,
+	0x4a, 0x3d, 0xc5, 0x5e, 0xc4, 0xfa, 0xe5, 0x0c, 0xed, 0xe0, 0xb7, 0x16, 0x5c, 0x90, 0x6a, 0xf6,
+	0x7c, 0x7a, 0x84, 0x6e, 0xe7, 0x15, 0x7d, 0xfb, 0x54, 0x45, 0xd2, 0xe2, 0x74, 0x55, 0x77, 0x87,
+	0x55, 0xd9, 0xa7, 0xab, 0x52, 0x8c, 0x99, 0xb2, 0x1b, 0xb0, 0x2c, 0x85, 0xd5, 0xfd, 0xb8, 0x4d,
+	0x13, 0x41, 0x8f, 0x55, 0x2b, 0xf4, 0xa3, 0x88, 0x26, 0x4a, 0x5e, 0x11, 0xeb, 0x17, 0xfb, 0x9f,
+	0x16, 0x2c, 0x49, 0x60, 0x83, 0xf4, 0x02, 0x46, 0x3c, 0xd4, 0x80, 0x4b, 0x11, 0x93, 0xc5, 0x67,
+	0x61, 0xe8, 0x8b, 0x90, 0x66, 0xfd, 0xf6, 0xed, 0x01, 0xef, 0xea, 0x18, 0xae, 0xc8, 0xf3, 0x57,
+	0x9e, 0x1c, 0xb2, 0xf8, 0xf5, 0x0c, 0x8e, 0x97, 0xa5, 0x7d, 0xff, 0x1d, 0x7d, 0x07, 0x4a, 0x34,
+	0x6e, 0xd3, 0x90, 0x26, 0x24, 0x70, 0x0e, 0x69, 0xcf, 0x44, 0x59, 0xcc, 0x06, 0x77, 0x68, 0x0f,
+	0x39, 0xb0, 0x4c, 0x23, 0xc5, 0x4b, 0x3d, 0x47, 0x12, 0x98, 0x98, 0x3f, 0x9c, 0x7c, 0x97, 0xe4,
+	0xc3, 0xc5, 0xa5, 0x8c, 0x4f, 0x4e, 0xd8, 0xd7, 0xa1, 0xf4, 0x62, 0xe7, 0x71, 0x47, 0xc4, 0x1d,
+	0xd1, 0x48, 0x18, 0x6b, 0x8d, 0x49, 0xc7, 0x5b, 0x50, 0x7c, 0xb1, 0xb3, 0x1b, 0xd3, 0xc8, 0x3b,
+	0x0d, 0xb5, 0x01, 0xe5, 0x17, 0x3b, 0x1f, 0x77, 0x82, 0xc0, 0x6f, 0xf9, 0x34, 0xb9, 0x47, 0x13,
+	0xbf, 0xab, 0x0e, 0xa9, 0xd3, 0x6c, 0xfe, 0x6d, 0xc1, 0xbc, 0x22, 0x46, 0x0f, 0x60, 0xae, 0xc9,
+	0xbc, 0x9e, 0xc9, 0xeb, 0xcd, 0x29, 0xce, 0x68, 0x69, 0x5e, 0x63, 0x5e, 0x0f, 0x2b, 0x02, 0xf4,
+	0x18, 0x2e, 0x90, 0x8e, 0x68, 0x3b, 0xdc, 0x3f, 0x30, 0x4d, 0xe5, 0xd6, 0x48, 0x91, 0xf2, 0x17,
+	0xaa, 0x94, 0x64, 0xab, 0x23, 0xda, 0xbb, 0xfe, 0x41, 0x44, 0x44, 0x27, 0xa1, 0x78, 0x91, 0xe8,
+	0x57, 0xf4, 0x43, 0x98, 0x8f, 0x65, 0x08, 0x26, 0xf9, 0x1f, 0x4c, 0x2e, 0x6d, 0x30, 0x69, 0x58,
+	0x93, 0xd8, 0x4f, 0x01, 0x3e, 0xea, 0xd2, 0x48, 0xa4, 0x51, 0x5f, 0x8c, 0xd2, 0x8c, 0x99, 0xd0,
+	0xdf, 0x19, 0xcf, 0xaf, 0x97, 0x56, 0x96, 0x62, 0xdc, 0xb7, 0xb5, 0x1d, 0x58, 0x52, 0xb4, 0xba,
+	0x98, 0xe7, 0xbf, 0x60, 0xed, 0x5f, 0x58, 0x80, 0x94, 0x87, 0x5a, 0xc2, 0x88, 0xe7, 0x12, 0x2e,
+	0x64, 0xb3, 0x43, 0xdf, 0x83, 0x39, 0xb7, 0xbf, 0xbb, 0xaf, 0x8f, 0xcf, 0xb4, 0xbc, 0xef, 0x76,
+	0xab, 0x15, 0x69, 0x84, 0x95, 0x09, 0xfa, 0x00, 0x0a, 0xe2, 0xd8, 0x94, 0xe8, 0xc6, 0x50, 0xd0,
+	0xe6, 0x52, 0xdd, 0xad, 0x56, 0x9e, 0x24, 0x24, 0xe2, 0x44, 0x9d, 0x6f, 0x0f, 0x3d, 0x5c, 0x10,
+	0xc7, 0xf6, 0x7f, 0x2c, 0xb8, 0x98, 0x15, 0x1d, 0x3d, 0x07, 0xd4, 0x24, 0x01, 0x89, 0xdc, 0x13,
+	0x82, 0x7d, 0x67, 0x5c, 0xb3, 0xa9, 0x69, 0x8b, 0x81, 0x70, 0x2f, 0x37, 0x87, 0x87, 0xf2, 0xb5,
+	0x59, 0x78, 0xfd, 0xda, 0xa0, 0xfb, 0x50, 0x48, 0x0e, 0x57, 0xe6, 0x46, 0x56, 0xcf, 0x69, 0x6b,
+	0x71, 0x8f, 0x26, 0x7e, 0xcb, 0xd7, 0xb7, 0xbc, 0x1d, 0xda, 0xc3, 0x85, 0xe4, 0xd0, 0xfe, 0xe3,
+	0xac, 0x09, 0x5c, 0x35, 0xd6, 0x67, 0xb0, 0xd8, 0xf5, 0xb9, 0xdf, 0x0c, 0xd2, 0xe4, 0xdf, 0x99,
+	0x72, 0xcf, 0x48, 0x96, 0xca, 0x9e, 0xa6, 0xd8, 0x9e, 0xc1, 0x29, 0x1b, 0x7a, 0x02, 0x0b, 0x2c,
+	0x26, 0x9f, 0x74, 0xa8, 0xa9, 0xcd, 0xe6, 0xeb, 0xf0, 0x3e, 0x56, 0x0c, 0xdb, 0x33, 0xd8, 0x70,
+	0x95, 0x7f, 0x67, 0xc1, 0xa2, 0x71, 0x86, 0x3e, 0x82, 0x79, 0x2e, 0x91, 0x46, 0xf8, 0xfa, 0x94,
+	0x0e, 0xb0, 0xb6, 0x46, 0xf7, 0x61, 0x4e, 0x35, 0x45, 0x2d, 0x73, 0x63, 0xba, 0xa6, 0xa8, 0x0e,
+	0x06, 0x65, 0x5f, 0x7e, 0x0c, 0x0b, 0x5a, 0xee, 0x39, 0x09, 0xab, 0x15, 0x01, 0xd4, 0x83, 0xd3,
+	0xf5, 0xe9, 0x91, 0xfd, 0xf3, 0x82, 0x29, 0x5b, 0x23, 0x20, 0x11, 0xaa, 0x19, 0xd1, 0xda, 0x43,
+	0x65, 0x3a, 0xd1, 0x5a, 0x30, 0x2a, 0xc3, 0x85, 0x98, 0x71, 0x5f, 0xae, 0x0d, 0x73, 0x23, 0xc8,
+	0xde, 0xd1, 0x2a, 0x40, 0x42, 0x22, 0x8f, 0x85, 0xfe, 0x8f, 0x69, 0xa2, 0x5a, 0x56, 0x11, 0x0f,
+	0x8c, 0xc8, 0xeb, 0x87, 0x3a, 0x5f, 0x9d, 0x66, 0xe0, 0x47, 0xf2, 0xae, 0xa3, 0x16, 0x66, 0x11,
+	0x97, 0xd4, 0x68, 0xcd, 0x0c, 0xa2, 0x35, 0x78, 0x43, 0xf5, 0xab, 0x0c, 0xe6, 0x24, 0x2b, 0xf3,
+	0x0a, 0xb8, 0xac, 0xc6, 0x53, 0x20, 0x3e, 0x01, 0xc9, 0xd5, 0x6e, 0x19, 0x46, 0xee, 0xda, 0x5f,
+	0x58, 0xb0, 0x60, 0xfa, 0xd3, 0x76, 0xae, 0xdb, 0xdf, 0x9a, 0x3c, 0x0b, 0xda, 0x7e, 0xa0, 0xdd,
+	0x3f, 0x4a, 0xbb, 0x73, 0x61, 0xda, 0xef, 0xd7, 0xdc, 0xc9, 0x97, 0xb6, 0xe7, 0xcf, 0x0a, 0x00,
+	0x7d, 0x1f, 0xe8, 0x39, 0x14, 0x55, 0x1f, 0x8d, 0xf5, 0x45, 0xc0, 0xe8, 0x7d, 0x7f, 0xba, 0xaa,
+	0x99, 0x5b, 0x04, 0x5e, 0x8a, 0x06, 0xae, 0x14, 0x27, 0xf7, 0xad, 0xc2, 0x39, 0xf4, 0xad, 0x35,
+	0x78, 0xe3, 0x28, 0x21, 0x71, 0x4c, 0xe5, 0x97, 0x77, 0xc8, 0xd4, 0xed, 0x42, 0xaf, 0x83, 0x65,
+	0x33, 0xfe, 0x88, 0x86, 0x4c, 0xde, 0x2f, 0x6e, 0xc0, 0x25, 0xd6, 0x3d, 0x74, 0x52, 0xb4, 0x04,
+	0x9a, 0xc5, 0xc0, 0xba, 0x87, 0xcf, 0xf4, 0xe8, 0x0e, 0xed, 0xd9, 0x3f, 0x9d, 0x4b, 0x93, 0xa2,
+	0x3a, 0xcf, 0xf3, 0xe1, 0xce, 0x73, 0x77, 0xda, 0xfa, 0x8d, 0x6b, 0x3d, 0x4f, 0x87, 0x5a, 0xcf,
+	0x9d, 0xd7, 0x22, 0x1e, 0xe9, 0x3d, 0x7f, 0x1b, 0xe8, 0x3d, 0xdb, 0xb0, 0xc0, 0x14, 0xd4, 0x68,
+	0x7f, 0x6f, 0x5a, 0x17, 0xd8, 0xd8, 0x9f, 0x57, 0xfb, 0x41, 0x35, 0x58, 0x32, 0xcb, 0x2b, 0x2b,
+	0xd5, 0xe8, 0x3d, 0x39, 0xbd, 0xd6, 0x9a, 0xe5, 0x23, 0x8f, 0x04, 0x88, 0xb3, 0xe7, 0x32, 0xce,
+	0x5a, 0xd8, 0xb9, 0xc5, 0x57, 0x2b, 0xc1, 0x92, 0x7e, 0xd2, 0x6d, 0xec, 0x37, 0xd9, 0xce, 0x50,
+	0x7d, 0xec, 0xb5, 0xbe, 0x34, 0xb6, 0xa0, 0xe8, 0x51, 0x2e, 0x9c, 0xf4, 0x0a, 0x5f, 0x98, 0xe8,
+	0xc3, 0x62, 0x49, 0xda, 0x98, 0x97, 0xfe, 0x67, 0xc1, 0xec, 0xe0, 0x67, 0xc1, 0xff, 0xb1, 0xab,
+	0xed, 0xc1, 0xca, 0x96, 0x0c, 0x56, 0x7e, 0x8c, 0x7a, 0x44, 0x90, 0x5a, 0xef, 0xa1, 0x87, 0xe9,
+	0x27, 0x1d, 0xca, 0x05, 0xda, 0x84, 0x0b, 0x2a, 0x11, 0x8e, 0xef, 0x99, 0x58, 0xdf, 0x1c, 0x97,
+	0x27, 0xc5, 0xf1, 0xd0, 0xc3, 0x8b, 0x44, 0x3f, 0xd8, 0x1e, 0x7c, 0xfd, 0x04, 0x5e, 0x1e, 0xb3,
+	0x88, 0x53, 0xf4, 0x00, 0x96, 0xd5, 0x8f, 0x36, 0xea, 0xb7, 0x35, 0x39, 0x6b, 0xca, 0x70, 0x6d,
+	0x1c, 0x7d, 0xca, 0x82, 0x4b, 0xca, 0x2e, 0x7d, 0xb5, 0x9f, 0x9d, 0xe0, 0x85, 0x9f, 0x24, 0xdf,
+	0x52, 0x3f, 0x68, 0x4d, 0x2e, 0x9f, 0x42, 0xf9, 0x24, 0xe2, 0x73, 0xd6, 0xbf, 0xf1, 0x97, 0x02,
+	0x14, 0x7f, 0xd4, 0xa1, 0x49, 0x6f, 0x97, 0x26, 0x5d, 0xdf, 0xa5, 0xe8, 0x73, 0x0b, 0x2e, 0x8f,
+	0x38, 0x46, 0xb5, 0xc9, 0x77, 0xc1, 0xb8, 0x62, 0x96, 0xeb, 0x67, 0xe2, 0x30, 0x81, 0x7f, 0x61,
+	0x01, 0x1a, 0xcd, 0x0b, 0x3a, 0x0b, 0x77, 0x5a, 0xae, 0xf2, 0xbd, 0xb3, 0x91, 0x68, 0x85, 0xef,
+	0x59, 0xb5, 0x4f, 0x67, 0xff, 0xf4, 0x72, 0xd5, 0xfa, 0xf2, 0xe5, 0xaa, 0xf5, 0xf7, 0x97, 0xab,
+	0xd6, 0xaf, 0x5e, 0xad, 0xce, 0x7c, 0xf9, 0x6a, 0x75, 0xe6, 0xaf, 0xaf, 0x56, 0x67, 0xe0, 0xbb,
+	0x2e, 0x0b, 0x27, 0xf6, 0x52, 0xbb, 0x9c, 0xfb, 0xfd, 0x34, 0x61, 0x82, 0x35, 0xac, 0x17, 0xde,
+	0x81, 0x2f, 0xda, 0x9d, 0xa6, 0xb4, 0x5b, 0x77, 0x19, 0x0f, 0x19, 0x5f, 0x4f, 0x68, 0x40, 0x7a,
+	0x34, 0x59, 0xef, 0x6e, 0x64, 0x8f, 0x6e, 0x9b, 0xf8, 0x11, 0x5f, 0x9f, 0xf4, 0x8f, 0x0d, 0x77,
+	0x72, 0x03, 0xdd, 0xea, 0xef, 0x0b, 0x73, 0x8d, 0x7a, 0x7d, 0xf7, 0x0f, 0x85, 0xb7, 0x1b, 0xa9,
+	0xd8, 0xba, 0x14, 0x5b, 0xcf, 0xc4, 0x0e, 0x4a, 0xab, 0xec, 0x55, 0xff, 0xdc, 0x47, 0xee, 0x4b,
+	0xe4, 0x7e, 0x86, 0xdc, 0x1f, 0x44, 0xee, 0xef, 0x55, 0x5f, 0x16, 0x6e, 0x4e, 0x88, 0xdc, 0x7f,
+	0xd0, 0xa8, 0xa5, 0x39, 0xfe, 0x57, 0xe1, 0xdd, 0xd4, 0x6a, 0x73, 0x53, 0x9a, 0xc9, 0x7f, 0x8d,
+	0xdd, 0xe6, 0xe6, 0xa0, 0xe1, 0xe6, 0xe6, 0x5e, 0xb5, 0xb9, 0xa0, 0x7e, 0xc2, 0xbf, 0xf9, 0xbf,
+	0x00, 0x00, 0x00, 0xff, 0xff, 0x43, 0xe1, 0xc9, 0xc2, 0x6e, 0x19, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -2356,7 +2622,28 @@ func (m *FmdMetaParameters_FixedPrecisionBits) MarshalToSizedBuffer(dAtA []byte)
 	dAtA[i] = 0x10
 	return len(dAtA) - i, nil
 }
-func (m *FmdParameters) Marshal() (dAtA []byte, err error) {
+func (m *FmdMetaParameters_SlidingWindow) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *FmdMetaParameters_SlidingWindow) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	if m.SlidingWindow != nil {
+		{
+			size, err := m.SlidingWindow.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintShieldedPool(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x1a
+	}
+	return len(dAtA) - i, nil
+}
+func (m *FmdMetaParameters_AlgorithmSlidingWindow) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -2366,30 +2653,30 @@ func (m *FmdParameters) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *FmdParameters) MarshalTo(dAtA []byte) (int, error) {
+func (m *FmdMetaParameters_AlgorithmSlidingWindow) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *FmdParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *FmdMetaParameters_AlgorithmSlidingWindow) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.AsOfBlockHeight != 0 {
-		i = encodeVarintShieldedPool(dAtA, i, uint64(m.AsOfBlockHeight))
+	if m.TargetedDetectionsPerWindow != 0 {
+		i = encodeVarintShieldedPool(dAtA, i, uint64(m.TargetedDetectionsPerWindow))
 		i--
 		dAtA[i] = 0x10
 	}
-	if m.PrecisionBits != 0 {
-		i = encodeVarintShieldedPool(dAtA, i, uint64(m.PrecisionBits))
+	if m.WindowUpdatePeriods != 0 {
+		i = encodeVarintShieldedPool(dAtA, i, uint64(m.WindowUpdatePeriods))
 		i--
 		dAtA[i] = 0x8
 	}
 	return len(dAtA) - i, nil
 }
 
-func (m *Note) Marshal() (dAtA []byte, err error) {
+func (m *FmdMetaParametersAlgorithmState) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -2399,19 +2686,38 @@ func (m *Note) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *Note) MarshalTo(dAtA []byte) (int, error) {
+func (m *FmdMetaParametersAlgorithmState) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *Note) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *FmdMetaParametersAlgorithmState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.Address != nil {
+	if m.State != nil {
 		{
-			size, err := m.Address.MarshalToSizedBuffer(dAtA[:i])
+			size := m.State.Size()
+			i -= size
+			if _, err := m.State.MarshalTo(dAtA[i:]); err != nil {
+				return 0, err
+			}
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *FmdMetaParametersAlgorithmState_Fixed) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *FmdMetaParametersAlgorithmState_Fixed) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	if m.Fixed != nil {
+		{
+			size, err := m.Fixed.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -2419,18 +2725,20 @@ func (m *Note) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			i = encodeVarintShieldedPool(dAtA, i, uint64(size))
 		}
 		i--
-		dAtA[i] = 0x1a
-	}
-	if len(m.Rseed) > 0 {
-		i -= len(m.Rseed)
-		copy(dAtA[i:], m.Rseed)
-		i = encodeVarintShieldedPool(dAtA, i, uint64(len(m.Rseed)))
-		i--
-		dAtA[i] = 0x12
+		dAtA[i] = 0xa
 	}
-	if m.Value != nil {
+	return len(dAtA) - i, nil
+}
+func (m *FmdMetaParametersAlgorithmState_SlidingWindow) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *FmdMetaParametersAlgorithmState_SlidingWindow) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	if m.SlidingWindow != nil {
 		{
-			size, err := m.Value.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.SlidingWindow.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -2438,12 +2746,11 @@ func (m *Note) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			i = encodeVarintShieldedPool(dAtA, i, uint64(size))
 		}
 		i--
-		dAtA[i] = 0xa
+		dAtA[i] = 0x12
 	}
 	return len(dAtA) - i, nil
 }
-
-func (m *NoteView) Marshal() (dAtA []byte, err error) {
+func (m *FmdMetaParametersAlgorithmState_FixedState) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -2453,22 +2760,160 @@ func (m *NoteView) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *NoteView) MarshalTo(dAtA []byte) (int, error) {
+func (m *FmdMetaParametersAlgorithmState_FixedState) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *NoteView) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *FmdMetaParametersAlgorithmState_FixedState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.Address != nil {
-		{
-			size, err := m.Address.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
+	return len(dAtA) - i, nil
+}
+
+func (m *FmdMetaParametersAlgorithmState_SlidingWindowState) 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 *FmdMetaParametersAlgorithmState_SlidingWindowState) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *FmdMetaParametersAlgorithmState_SlidingWindowState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.ApproximateClueCount != 0 {
+		i = encodeVarintShieldedPool(dAtA, i, uint64(m.ApproximateClueCount))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *FmdParameters) 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 *FmdParameters) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *FmdParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.AsOfBlockHeight != 0 {
+		i = encodeVarintShieldedPool(dAtA, i, uint64(m.AsOfBlockHeight))
+		i--
+		dAtA[i] = 0x10
+	}
+	if m.PrecisionBits != 0 {
+		i = encodeVarintShieldedPool(dAtA, i, uint64(m.PrecisionBits))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *Note) 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 *Note) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Note) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.Address != nil {
+		{
+			size, err := m.Address.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintShieldedPool(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x1a
+	}
+	if len(m.Rseed) > 0 {
+		i -= len(m.Rseed)
+		copy(dAtA[i:], m.Rseed)
+		i = encodeVarintShieldedPool(dAtA, i, uint64(len(m.Rseed)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if m.Value != nil {
+		{
+			size, err := m.Value.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintShieldedPool(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *NoteView) 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 *NoteView) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *NoteView) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.Address != nil {
+		{
+			size, err := m.Address.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
 			i -= size
 			i = encodeVarintShieldedPool(dAtA, i, uint64(size))
 		}
@@ -3715,6 +4160,90 @@ func (m *FmdMetaParameters_FixedPrecisionBits) Size() (n int) {
 	n += 1 + sovShieldedPool(uint64(m.FixedPrecisionBits))
 	return n
 }
+func (m *FmdMetaParameters_SlidingWindow) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.SlidingWindow != nil {
+		l = m.SlidingWindow.Size()
+		n += 1 + l + sovShieldedPool(uint64(l))
+	}
+	return n
+}
+func (m *FmdMetaParameters_AlgorithmSlidingWindow) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.WindowUpdatePeriods != 0 {
+		n += 1 + sovShieldedPool(uint64(m.WindowUpdatePeriods))
+	}
+	if m.TargetedDetectionsPerWindow != 0 {
+		n += 1 + sovShieldedPool(uint64(m.TargetedDetectionsPerWindow))
+	}
+	return n
+}
+
+func (m *FmdMetaParametersAlgorithmState) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.State != nil {
+		n += m.State.Size()
+	}
+	return n
+}
+
+func (m *FmdMetaParametersAlgorithmState_Fixed) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Fixed != nil {
+		l = m.Fixed.Size()
+		n += 1 + l + sovShieldedPool(uint64(l))
+	}
+	return n
+}
+func (m *FmdMetaParametersAlgorithmState_SlidingWindow) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.SlidingWindow != nil {
+		l = m.SlidingWindow.Size()
+		n += 1 + l + sovShieldedPool(uint64(l))
+	}
+	return n
+}
+func (m *FmdMetaParametersAlgorithmState_FixedState) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	return n
+}
+
+func (m *FmdMetaParametersAlgorithmState_SlidingWindowState) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.ApproximateClueCount != 0 {
+		n += 1 + sovShieldedPool(uint64(m.ApproximateClueCount))
+	}
+	return n
+}
+
 func (m *FmdParameters) Size() (n int) {
 	if m == nil {
 		return 0
@@ -4697,6 +5226,368 @@ func (m *FmdMetaParameters) Unmarshal(dAtA []byte) error {
 				}
 			}
 			m.Algorithm = &FmdMetaParameters_FixedPrecisionBits{v}
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SlidingWindow", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowShieldedPool
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthShieldedPool
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthShieldedPool
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			v := &FmdMetaParameters_AlgorithmSlidingWindow{}
+			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			m.Algorithm = &FmdMetaParameters_SlidingWindow{v}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipShieldedPool(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthShieldedPool
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *FmdMetaParameters_AlgorithmSlidingWindow) 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 ErrIntOverflowShieldedPool
+			}
+			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: AlgorithmSlidingWindow: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AlgorithmSlidingWindow: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field WindowUpdatePeriods", wireType)
+			}
+			m.WindowUpdatePeriods = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowShieldedPool
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.WindowUpdatePeriods |= uint32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field TargetedDetectionsPerWindow", wireType)
+			}
+			m.TargetedDetectionsPerWindow = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowShieldedPool
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.TargetedDetectionsPerWindow |= uint32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipShieldedPool(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthShieldedPool
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *FmdMetaParametersAlgorithmState) 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 ErrIntOverflowShieldedPool
+			}
+			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: FmdMetaParametersAlgorithmState: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: FmdMetaParametersAlgorithmState: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Fixed", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowShieldedPool
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthShieldedPool
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthShieldedPool
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			v := &FmdMetaParametersAlgorithmState_FixedState{}
+			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			m.State = &FmdMetaParametersAlgorithmState_Fixed{v}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SlidingWindow", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowShieldedPool
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthShieldedPool
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthShieldedPool
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			v := &FmdMetaParametersAlgorithmState_SlidingWindowState{}
+			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			m.State = &FmdMetaParametersAlgorithmState_SlidingWindow{v}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipShieldedPool(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthShieldedPool
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *FmdMetaParametersAlgorithmState_FixedState) 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 ErrIntOverflowShieldedPool
+			}
+			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: FixedState: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: FixedState: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipShieldedPool(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthShieldedPool
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *FmdMetaParametersAlgorithmState_SlidingWindowState) 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 ErrIntOverflowShieldedPool
+			}
+			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: SlidingWindowState: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: SlidingWindowState: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ApproximateClueCount", wireType)
+			}
+			m.ApproximateClueCount = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowShieldedPool
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ApproximateClueCount |= uint32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipShieldedPool(dAtA[iNdEx:])
diff --git a/relayer/chains/penumbra/core/component/stake/v1/stake.pb.go b/relayer/chains/penumbra/core/component/stake/v1/stake.pb.go
index 37f8baec5..41359461a 100644
--- a/relayer/chains/penumbra/core/component/stake/v1/stake.pb.go
+++ b/relayer/chains/penumbra/core/component/stake/v1/stake.pb.go
@@ -2354,780 +2354,998 @@ func (m *EventTombstoneValidator) GetVotingPower() uint64 {
 	return 0
 }
 
-func init() {
-	proto.RegisterEnum("penumbra.core.component.stake.v1.BondingState_BondingStateEnum", BondingState_BondingStateEnum_name, BondingState_BondingStateEnum_value)
-	proto.RegisterEnum("penumbra.core.component.stake.v1.ValidatorState_ValidatorStateEnum", ValidatorState_ValidatorStateEnum_name, ValidatorState_ValidatorStateEnum_value)
-	proto.RegisterType((*ZKUndelegateClaimProof)(nil), "penumbra.core.component.stake.v1.ZKUndelegateClaimProof")
-	proto.RegisterType((*Validator)(nil), "penumbra.core.component.stake.v1.Validator")
-	proto.RegisterType((*ValidatorList)(nil), "penumbra.core.component.stake.v1.ValidatorList")
-	proto.RegisterType((*FundingStream)(nil), "penumbra.core.component.stake.v1.FundingStream")
-	proto.RegisterType((*FundingStream_ToAddress)(nil), "penumbra.core.component.stake.v1.FundingStream.ToAddress")
-	proto.RegisterType((*FundingStream_ToCommunityPool)(nil), "penumbra.core.component.stake.v1.FundingStream.ToCommunityPool")
-	proto.RegisterType((*RateData)(nil), "penumbra.core.component.stake.v1.RateData")
-	proto.RegisterType((*BaseRateData)(nil), "penumbra.core.component.stake.v1.BaseRateData")
-	proto.RegisterType((*ValidatorStatus)(nil), "penumbra.core.component.stake.v1.ValidatorStatus")
-	proto.RegisterType((*BondingState)(nil), "penumbra.core.component.stake.v1.BondingState")
-	proto.RegisterType((*ValidatorState)(nil), "penumbra.core.component.stake.v1.ValidatorState")
-	proto.RegisterType((*ValidatorInfo)(nil), "penumbra.core.component.stake.v1.ValidatorInfo")
-	proto.RegisterType((*ValidatorDefinition)(nil), "penumbra.core.component.stake.v1.ValidatorDefinition")
-	proto.RegisterType((*Delegate)(nil), "penumbra.core.component.stake.v1.Delegate")
-	proto.RegisterType((*Undelegate)(nil), "penumbra.core.component.stake.v1.Undelegate")
-	proto.RegisterType((*UndelegateClaim)(nil), "penumbra.core.component.stake.v1.UndelegateClaim")
-	proto.RegisterType((*UndelegateClaimBody)(nil), "penumbra.core.component.stake.v1.UndelegateClaimBody")
-	proto.RegisterType((*UndelegateClaimPlan)(nil), "penumbra.core.component.stake.v1.UndelegateClaimPlan")
-	proto.RegisterType((*DelegationChanges)(nil), "penumbra.core.component.stake.v1.DelegationChanges")
-	proto.RegisterType((*Uptime)(nil), "penumbra.core.component.stake.v1.Uptime")
-	proto.RegisterType((*CurrentConsensusKeys)(nil), "penumbra.core.component.stake.v1.CurrentConsensusKeys")
-	proto.RegisterType((*Penalty)(nil), "penumbra.core.component.stake.v1.Penalty")
-	proto.RegisterType((*GetValidatorInfoRequest)(nil), "penumbra.core.component.stake.v1.GetValidatorInfoRequest")
-	proto.RegisterType((*GetValidatorInfoResponse)(nil), "penumbra.core.component.stake.v1.GetValidatorInfoResponse")
-	proto.RegisterType((*ValidatorInfoRequest)(nil), "penumbra.core.component.stake.v1.ValidatorInfoRequest")
-	proto.RegisterType((*ValidatorInfoResponse)(nil), "penumbra.core.component.stake.v1.ValidatorInfoResponse")
-	proto.RegisterType((*ValidatorStatusRequest)(nil), "penumbra.core.component.stake.v1.ValidatorStatusRequest")
-	proto.RegisterType((*ValidatorStatusResponse)(nil), "penumbra.core.component.stake.v1.ValidatorStatusResponse")
-	proto.RegisterType((*ValidatorPenaltyRequest)(nil), "penumbra.core.component.stake.v1.ValidatorPenaltyRequest")
-	proto.RegisterType((*ValidatorPenaltyResponse)(nil), "penumbra.core.component.stake.v1.ValidatorPenaltyResponse")
-	proto.RegisterType((*CurrentValidatorRateRequest)(nil), "penumbra.core.component.stake.v1.CurrentValidatorRateRequest")
-	proto.RegisterType((*CurrentValidatorRateResponse)(nil), "penumbra.core.component.stake.v1.CurrentValidatorRateResponse")
-	proto.RegisterType((*ValidatorUptimeRequest)(nil), "penumbra.core.component.stake.v1.ValidatorUptimeRequest")
-	proto.RegisterType((*ValidatorUptimeResponse)(nil), "penumbra.core.component.stake.v1.ValidatorUptimeResponse")
-	proto.RegisterType((*StakeParameters)(nil), "penumbra.core.component.stake.v1.StakeParameters")
-	proto.RegisterType((*GenesisContent)(nil), "penumbra.core.component.stake.v1.GenesisContent")
-	proto.RegisterType((*EventTombstoneValidator)(nil), "penumbra.core.component.stake.v1.EventTombstoneValidator")
+type EventValidatorStateChange struct {
+	// The validator's identity key.
+	IdentityKey *v1.IdentityKey `protobuf:"bytes,1,opt,name=identity_key,json=identityKey,proto3" json:"identity_key,omitempty"`
+	// The new state of the validator.
+	State *ValidatorState `protobuf:"bytes,2,opt,name=state,proto3" json:"state,omitempty"`
 }
 
-func init() {
-	proto.RegisterFile("penumbra/core/component/stake/v1/stake.proto", fileDescriptor_061b0086577193ed)
+func (m *EventValidatorStateChange) Reset()         { *m = EventValidatorStateChange{} }
+func (m *EventValidatorStateChange) String() string { return proto.CompactTextString(m) }
+func (*EventValidatorStateChange) ProtoMessage()    {}
+func (*EventValidatorStateChange) Descriptor() ([]byte, []int) {
+	return fileDescriptor_061b0086577193ed, []int{35}
 }
-
-var fileDescriptor_061b0086577193ed = []byte{
-	// 2416 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x5a, 0xcb, 0x73, 0x1b, 0xc7,
-	0xd1, 0xe7, 0x82, 0xe0, 0x03, 0x4d, 0x3c, 0xc8, 0xd1, 0x0b, 0xa2, 0x65, 0x0a, 0x5e, 0xc9, 0x9f,
-	0x69, 0x5b, 0x1f, 0x68, 0x32, 0x0f, 0xc7, 0x74, 0xc5, 0x36, 0xf1, 0x10, 0x05, 0x89, 0xa2, 0xe0,
-	0x05, 0xc5, 0x38, 0x8a, 0x2a, 0x9b, 0x05, 0x76, 0x48, 0x6e, 0x09, 0x3b, 0x03, 0xef, 0x0c, 0x40,
-	0xb1, 0x72, 0xf3, 0x21, 0x55, 0xbe, 0xf9, 0x92, 0xaa, 0x9c, 0x72, 0xc8, 0x31, 0xb7, 0x54, 0x1e,
-	0xff, 0x40, 0x2a, 0x55, 0xa9, 0x9c, 0x7c, 0x49, 0x25, 0x95, 0x5c, 0x52, 0xd2, 0x21, 0x55, 0xa9,
-	0x72, 0xae, 0xb9, 0xa6, 0x66, 0x76, 0x76, 0xb1, 0x0b, 0x90, 0x22, 0xc0, 0x30, 0x29, 0x5d, 0xa4,
-	0x9d, 0x9e, 0x5f, 0xf7, 0x74, 0xf7, 0xf4, 0x74, 0xf7, 0x0c, 0x08, 0xb7, 0x3a, 0x98, 0x74, 0xdd,
-	0xa6, 0x67, 0xad, 0xb4, 0xa8, 0x87, 0x57, 0x5a, 0xd4, 0xed, 0x50, 0x82, 0x09, 0x5f, 0x61, 0xdc,
-	0x7a, 0x82, 0x57, 0x7a, 0xab, 0xfe, 0x47, 0xb1, 0xe3, 0x51, 0x4e, 0x51, 0x21, 0x40, 0x17, 0x05,
-	0xba, 0x18, 0xa2, 0x8b, 0x3e, 0xa8, 0xb7, 0xba, 0xa8, 0xc7, 0xe5, 0x59, 0x8c, 0x61, 0x2e, 0xa4,
-	0xc8, 0x0f, 0x5f, 0xca, 0xe2, 0xf2, 0x89, 0x6b, 0xb6, 0x24, 0x96, 0xb5, 0x02, 0x64, 0x21, 0x8e,
-	0x7c, 0x82, 0x8f, 0x98, 0x00, 0x88, 0xff, 0x15, 0x62, 0x29, 0x8e, 0x20, 0x5d, 0x57, 0x00, 0x48,
-	0xd7, 0xf5, 0xe7, 0xf5, 0x22, 0x5c, 0x7e, 0x74, 0xef, 0x21, 0xb1, 0x71, 0x1b, 0xef, 0x5b, 0x1c,
-	0x97, 0xdb, 0x96, 0xe3, 0xd6, 0x3d, 0x4a, 0xf7, 0xd0, 0x45, 0x98, 0x72, 0x08, 0xc1, 0x5e, 0x5e,
-	0x2b, 0x68, 0xcb, 0x69, 0xc3, 0x1f, 0xe8, 0xbf, 0x98, 0x84, 0xd4, 0xae, 0xd5, 0x76, 0x6c, 0x8b,
-	0x53, 0x0f, 0x55, 0x21, 0xed, 0xd8, 0x98, 0x70, 0x87, 0x1f, 0x99, 0x4f, 0xf0, 0x91, 0x84, 0xce,
-	0xad, 0xe9, 0xc5, 0xb8, 0x1b, 0xa4, 0x3a, 0xbd, 0xd5, 0x62, 0x4d, 0x41, 0xef, 0xe1, 0x23, 0x63,
-	0xce, 0xe9, 0x0f, 0xd0, 0x0d, 0xc8, 0xb4, 0x28, 0x61, 0x98, 0xb0, 0x2e, 0x93, 0x72, 0x12, 0x72,
-	0xc9, 0x74, 0x48, 0x14, 0x20, 0x04, 0x49, 0x62, 0xb9, 0x38, 0x3f, 0x59, 0xd0, 0x96, 0x53, 0x86,
-	0xfc, 0x46, 0x79, 0x98, 0x39, 0xc4, 0x4d, 0xe6, 0x70, 0x9c, 0x4f, 0x4a, 0x72, 0x30, 0x44, 0x05,
-	0x98, 0xb3, 0x31, 0x6b, 0x79, 0x4e, 0x87, 0x3b, 0x94, 0xe4, 0xa7, 0xe4, 0x6c, 0x94, 0x24, 0x78,
-	0x31, 0xb1, 0x9a, 0x6d, 0x6c, 0xe7, 0x67, 0x0b, 0xda, 0xf2, 0xac, 0x11, 0x0c, 0xd1, 0x27, 0x90,
-	0xdb, 0xeb, 0x12, 0xdb, 0x21, 0xfb, 0x26, 0xe3, 0x1e, 0xb6, 0x5c, 0x96, 0x9f, 0x2e, 0x4c, 0x2e,
-	0xcf, 0xad, 0xad, 0x14, 0x4f, 0xdb, 0xdf, 0xe2, 0x6d, 0x9f, 0xb1, 0x21, 0xf9, 0x8c, 0xec, 0x5e,
-	0x74, 0xc8, 0xd0, 0x1b, 0x90, 0x63, 0xf8, 0xd3, 0x2e, 0x26, 0x2d, 0x6c, 0x0a, 0x41, 0xd8, 0xcb,
-	0xcf, 0x14, 0xb4, 0xe5, 0x8c, 0x91, 0x0d, 0xc8, 0xdb, 0x92, 0x8a, 0xee, 0x41, 0x76, 0x9f, 0xf6,
-	0xb0, 0x47, 0x2c, 0x01, 0x15, 0x2e, 0x49, 0x49, 0xd7, 0xde, 0x3c, 0xc1, 0xb5, 0x9b, 0x21, 0x58,
-	0x38, 0x37, 0xb3, 0x1f, 0x1d, 0xea, 0x8f, 0x20, 0x13, 0x6e, 0xd9, 0x96, 0xc3, 0x38, 0xaa, 0x41,
-	0xb6, 0x17, 0x10, 0x84, 0x70, 0x96, 0xd7, 0xa4, 0x7d, 0xa3, 0x6c, 0x5c, 0x26, 0xe4, 0xbc, 0x87,
-	0x8f, 0x98, 0xfe, 0xa7, 0x04, 0x64, 0x62, 0x36, 0xa3, 0x47, 0x00, 0x9c, 0x9a, 0x96, 0x6d, 0x7b,
-	0x98, 0x31, 0x15, 0x11, 0xef, 0x8d, 0xe9, 0xb8, 0xe2, 0x0e, 0xdd, 0xf0, 0x05, 0xdc, 0x99, 0x30,
-	0x52, 0x3c, 0x18, 0x20, 0x17, 0x16, 0x38, 0x35, 0x5b, 0xd4, 0x75, 0xbb, 0x44, 0xc4, 0x5c, 0x87,
-	0xd2, 0xb6, 0x0c, 0x96, 0xb9, 0xb5, 0x0f, 0xc7, 0x5f, 0xa2, 0x1c, 0xc8, 0xa9, 0x53, 0xda, 0xbe,
-	0x33, 0x61, 0xe4, 0x78, 0x9c, 0xb4, 0xf8, 0x11, 0xa4, 0x42, 0x45, 0x44, 0xbc, 0x44, 0x8d, 0x4a,
-	0x19, 0xc1, 0x10, 0x5d, 0x85, 0x59, 0xcf, 0xe2, 0xd8, 0x6c, 0x76, 0x98, 0x54, 0x26, 0x63, 0xcc,
-	0x88, 0x71, 0xa9, 0xc3, 0x16, 0x6f, 0x41, 0x6e, 0x60, 0x9d, 0x17, 0xa0, 0x4b, 0x73, 0x90, 0xf2,
-	0x70, 0xcb, 0xe9, 0x38, 0x98, 0x70, 0xfd, 0xa7, 0x09, 0x98, 0x35, 0x2c, 0x8e, 0x2b, 0x16, 0xb7,
-	0xce, 0xef, 0xa0, 0xcd, 0xe1, 0x0e, 0x6d, 0x1d, 0x98, 0x0e, 0xb1, 0xf1, 0x53, 0xb9, 0x7c, 0xb2,
-	0x94, 0xc8, 0x6b, 0x06, 0x48, 0x72, 0x4d, 0x50, 0x51, 0x1d, 0x2e, 0xf5, 0xa3, 0xc3, 0xc3, 0x87,
-	0x96, 0x67, 0x9b, 0x42, 0x43, 0x79, 0xc4, 0xe6, 0xd6, 0xae, 0x0d, 0x2c, 0x2a, 0x72, 0x49, 0x6f,
-	0xb5, 0xb8, 0xe1, 0xd2, 0x2e, 0xe1, 0xc6, 0x85, 0x90, 0xd5, 0x90, 0x9c, 0xc2, 0x02, 0xb4, 0x03,
-	0x57, 0xfa, 0x12, 0xf1, 0xd3, 0xd6, 0x81, 0x45, 0xf6, 0xb1, 0x2f, 0x73, 0x6a, 0x04, 0x99, 0x7d,
-	0x75, 0xaa, 0x8a, 0x57, 0x48, 0xd5, 0x7f, 0xab, 0x41, 0xba, 0x64, 0x31, 0x1c, 0x3a, 0xe9, 0x7a,
-	0xdc, 0x3a, 0xe1, 0xa3, 0x64, 0xcc, 0xb2, 0xdb, 0x30, 0xdf, 0xb4, 0x18, 0x8e, 0x19, 0x95, 0x18,
-	0x41, 0x81, 0xac, 0xe0, 0x8a, 0xd8, 0x73, 0x17, 0x90, 0x94, 0x13, 0x37, 0x65, 0x72, 0x04, 0x49,
-	0x72, 0xfd, 0x98, 0x15, 0xbf, 0x49, 0x40, 0x2e, 0x3c, 0x9d, 0x0d, 0x6e, 0xf1, 0x2e, 0x3b, 0xaf,
-	0xdd, 0xbe, 0x0d, 0x53, 0x8c, 0xf7, 0x6d, 0x7c, 0xe7, 0xf4, 0x13, 0x12, 0x53, 0x04, 0x1b, 0x3e,
-	0x3b, 0xfa, 0x10, 0xd2, 0x3d, 0xca, 0x45, 0x3a, 0xec, 0xd0, 0x43, 0xec, 0x8d, 0x64, 0xe8, 0x9c,
-	0xcf, 0x51, 0x17, 0x0c, 0xa8, 0x01, 0x99, 0x26, 0x0d, 0x12, 0x6a, 0x3f, 0x92, 0x8a, 0xa7, 0x2b,
-	0x54, 0xa2, 0xea, 0xc8, 0x0a, 0x75, 0xd2, 0xcd, 0xc8, 0x48, 0xff, 0x4b, 0x02, 0xd2, 0xd1, 0x69,
-	0xf4, 0x30, 0x30, 0x57, 0xb8, 0x2b, 0x3b, 0x4a, 0x42, 0x88, 0xb2, 0xc7, 0x06, 0x55, 0xd2, 0x75,
-	0x03, 0xeb, 0x6f, 0xc1, 0x7c, 0x97, 0x88, 0x95, 0x99, 0x69, 0x71, 0x53, 0x46, 0x53, 0xe4, 0xe0,
-	0x64, 0xd5, 0xdc, 0x06, 0xaf, 0x8a, 0x19, 0xf4, 0x16, 0x2c, 0x44, 0xd0, 0x07, 0xd8, 0xd9, 0x3f,
-	0xe0, 0xd2, 0x61, 0x49, 0x23, 0x17, 0x42, 0xef, 0x48, 0xb2, 0xfe, 0x13, 0x0d, 0xe6, 0x07, 0x57,
-	0x45, 0x3a, 0x2c, 0x95, 0x1e, 0x6c, 0x57, 0x6a, 0xdb, 0x9b, 0x66, 0x63, 0x67, 0x63, 0xa7, 0x6a,
-	0x56, 0xb7, 0x1f, 0xde, 0x37, 0x1f, 0x6e, 0x37, 0xea, 0xd5, 0x72, 0xed, 0x76, 0xad, 0x5a, 0x99,
-	0x9f, 0x40, 0xaf, 0xc2, 0xd5, 0x63, 0x30, 0x82, 0x54, 0xad, 0xcc, 0x6b, 0xa8, 0x00, 0xd7, 0x8e,
-	0x15, 0xa1, 0x88, 0xf3, 0x09, 0x74, 0x1d, 0x5e, 0x39, 0x11, 0x51, 0xad, 0xcc, 0x4f, 0xea, 0xff,
-	0x4a, 0x40, 0x36, 0x1e, 0x0c, 0xe8, 0xbb, 0x71, 0xf7, 0x96, 0xc7, 0x8d, 0xa6, 0x81, 0x61, 0xc4,
-	0xc5, 0xfa, 0xe7, 0x09, 0x40, 0xc3, 0xb3, 0xe8, 0x26, 0x14, 0x76, 0x37, 0xb6, 0x6a, 0x95, 0x8d,
-	0x9d, 0x07, 0xc6, 0xc9, 0xce, 0x28, 0xc0, 0xb5, 0x63, 0x51, 0x95, 0xea, 0xed, 0xda, 0xb6, 0xf4,
-	0xc7, 0x6b, 0xf0, 0xea, 0xb1, 0x88, 0xda, 0xf6, 0x46, 0x79, 0xa7, 0xb6, 0x5b, 0xf5, 0x1d, 0x72,
-	0x2c, 0x44, 0x01, 0x26, 0x4f, 0x04, 0xdc, 0xdd, 0xa8, 0x6d, 0x55, 0x2b, 0xf3, 0x49, 0x74, 0x03,
-	0xae, 0x1f, 0x0b, 0xd8, 0x79, 0x70, 0xbf, 0xd4, 0xd8, 0x79, 0x20, 0x34, 0x99, 0x3a, 0x51, 0x93,
-	0x4a, 0xad, 0xb1, 0x51, 0x12, 0x72, 0xa6, 0xf5, 0x7f, 0x6a, 0x91, 0x6a, 0x5d, 0x23, 0x7b, 0x14,
-	0xd5, 0x20, 0x15, 0x26, 0x40, 0x95, 0x0a, 0xde, 0x1e, 0xc3, 0xf9, 0x46, 0x9f, 0x1b, 0xd5, 0x60,
-	0x9a, 0xc9, 0x14, 0xa3, 0x52, 0xc2, 0xea, 0x98, 0x9b, 0xd8, 0x65, 0x86, 0x12, 0x80, 0x36, 0x21,
-	0x25, 0xcb, 0x98, 0x6d, 0x71, 0x4b, 0x65, 0x84, 0xb7, 0x4e, 0x97, 0x16, 0xe4, 0x6a, 0x43, 0xd6,
-	0x40, 0xf1, 0xa5, 0xff, 0x10, 0x2e, 0x84, 0x6b, 0x54, 0xf0, 0x9e, 0x43, 0x1c, 0xd9, 0x9e, 0x9d,
-	0xa3, 0xd5, 0x57, 0x61, 0xd6, 0xea, 0xf2, 0x03, 0x93, 0x39, 0xfb, 0xaa, 0xb3, 0x9c, 0x11, 0xe3,
-	0x86, 0xb3, 0xaf, 0x7f, 0x91, 0x80, 0xd9, 0x8a, 0xea, 0x7d, 0xd1, 0xc7, 0x80, 0xfa, 0x65, 0x2a,
-	0x48, 0xa4, 0x63, 0x24, 0xdf, 0x85, 0x90, 0x3b, 0xa0, 0x0e, 0x96, 0xa4, 0xc4, 0x50, 0x49, 0xaa,
-	0x82, 0x4a, 0x0b, 0xd8, 0x36, 0x2d, 0x99, 0x3a, 0x47, 0x4a, 0xaf, 0xd9, 0x80, 0xc9, 0x1f, 0xa3,
-	0x1a, 0x2c, 0xa8, 0x16, 0xde, 0xa1, 0x24, 0x10, 0x34, 0x4a, 0xbd, 0x9e, 0xef, 0xb3, 0xf9, 0x14,
-	0xfd, 0xef, 0x09, 0x80, 0xfe, 0x85, 0xe0, 0xbf, 0xe1, 0x94, 0x22, 0x2c, 0x30, 0x6e, 0x79, 0x2a,
-	0x99, 0x0e, 0xf5, 0x22, 0x39, 0x39, 0x59, 0x7d, 0x89, 0x7d, 0x84, 0x2a, 0x00, 0x7b, 0x1e, 0x75,
-	0x55, 0x35, 0xf0, 0x7b, 0x98, 0xd7, 0x4f, 0x8e, 0xce, 0x16, 0x17, 0xd2, 0xa4, 0x45, 0x46, 0x4a,
-	0x30, 0xca, 0x4f, 0xdd, 0x83, 0xdc, 0xc0, 0xcd, 0x0b, 0xd5, 0x20, 0xd9, 0xa4, 0x76, 0xe0, 0xdf,
-	0x6f, 0x9c, 0x1e, 0xf0, 0x03, 0x02, 0x4a, 0xd4, 0x3e, 0x32, 0xa4, 0x08, 0x71, 0x7f, 0xeb, 0x88,
-	0x8b, 0x9c, 0x0a, 0x79, 0x7f, 0xa0, 0x7f, 0x95, 0x80, 0x0b, 0xc7, 0xf0, 0xbc, 0x0c, 0xdb, 0x5c,
-	0x86, 0x99, 0x0e, 0x26, 0x56, 0x9b, 0x1f, 0xa9, 0xed, 0x7d, 0xf3, 0x74, 0xf3, 0xeb, 0x3e, 0x83,
-	0x11, 0x70, 0xa2, 0x4f, 0x44, 0x6b, 0xd6, 0x96, 0xb7, 0x26, 0x71, 0x4d, 0x70, 0xb8, 0x8b, 0xc3,
-	0x5d, 0x1e, 0x94, 0xe7, 0xdf, 0xb9, 0x45, 0x1f, 0xe0, 0x73, 0x94, 0x43, 0x06, 0x63, 0xa1, 0x39,
-	0x48, 0x42, 0x5f, 0x87, 0xcb, 0x7e, 0x40, 0xa9, 0x36, 0xc6, 0x0b, 0xcb, 0xfb, 0x94, 0x3c, 0xd5,
-	0x17, 0xc3, 0xd9, 0x86, 0x98, 0x54, 0x35, 0xfe, 0xaf, 0x93, 0x43, 0xfe, 0xae, 0xb7, 0x2d, 0xf2,
-	0x92, 0xf9, 0x3b, 0x79, 0x66, 0x7f, 0x6f, 0x06, 0xdd, 0x91, 0xf0, 0x8a, 0x3a, 0x53, 0xa3, 0xf4,
-	0xf4, 0xb9, 0x90, 0x4b, 0x1d, 0xa9, 0x37, 0x45, 0x6f, 0xee, 0x6f, 0x5c, 0xb3, 0xed, 0xc8, 0x99,
-	0xfc, 0xb4, 0x8c, 0xdc, 0x9c, 0xa2, 0x97, 0x14, 0x19, 0x2d, 0xc3, 0xbc, 0x0c, 0xe6, 0x10, 0x68,
-	0xfa, 0xd7, 0xe8, 0xb4, 0x91, 0x95, 0xf4, 0x00, 0x68, 0x1c, 0x83, 0x64, 0xf2, 0xb2, 0x3f, 0x88,
-	0x6c, 0xbc, 0x60, 0x77, 0x53, 0x2f, 0xd8, 0xdd, 0x5f, 0x6b, 0xb0, 0x50, 0x09, 0x93, 0x43, 0x59,
-	0x76, 0xf5, 0x0c, 0x6d, 0xc1, 0x5c, 0x3f, 0x63, 0x04, 0x77, 0xeb, 0x11, 0x8a, 0x63, 0x50, 0x88,
-	0x8c, 0x28, 0x3b, 0x32, 0x20, 0xd3, 0x25, 0x51, 0x79, 0x09, 0x29, 0xef, 0xd6, 0x38, 0xb9, 0xc1,
-	0x88, 0x8b, 0xd0, 0xdb, 0x30, 0xfd, 0xb0, 0xc3, 0x1d, 0x17, 0xa3, 0xb7, 0x01, 0x59, 0xcc, 0x94,
-	0x1e, 0xa2, 0xad, 0x27, 0x81, 0xcd, 0xfe, 0xd5, 0x29, 0x67, 0xb1, 0x07, 0x7b, 0x25, 0x41, 0xf7,
-	0xcd, 0x45, 0xaf, 0x02, 0x1c, 0x3a, 0xc4, 0xa6, 0x87, 0x66, 0x1b, 0x13, 0x75, 0x79, 0x4d, 0xf9,
-	0x94, 0x2d, 0x4c, 0xd0, 0x65, 0x98, 0x6e, 0x3a, 0xbc, 0x87, 0x5b, 0xf2, 0xfc, 0xa6, 0x0d, 0x35,
-	0xd2, 0x9b, 0x70, 0xb1, 0xdc, 0xf5, 0x3c, 0x4c, 0x78, 0x39, 0xf2, 0xa0, 0xc3, 0xd0, 0x5d, 0xc8,
-	0xc6, 0x9e, 0x7d, 0x02, 0x57, 0xdd, 0x38, 0x21, 0xfe, 0xa3, 0xdc, 0x46, 0x26, 0xfa, 0x38, 0xc4,
-	0xf4, 0xeb, 0x30, 0xa3, 0x62, 0xf3, 0x84, 0x87, 0xab, 0x1f, 0xc0, 0x95, 0x4d, 0xcc, 0x63, 0x9d,
-	0x95, 0x81, 0x3f, 0xed, 0x62, 0xc6, 0x87, 0xae, 0x5b, 0x89, 0x33, 0x5d, 0xb7, 0x74, 0x0f, 0xf2,
-	0xc3, 0x2b, 0xb0, 0x8e, 0x50, 0x13, 0xed, 0x46, 0x5f, 0x5c, 0x1c, 0xb2, 0x47, 0xd5, 0x51, 0x5f,
-	0x19, 0xa3, 0xa5, 0x91, 0x02, 0xfb, 0xcf, 0x2f, 0x62, 0xa8, 0xbf, 0x0f, 0x17, 0x8f, 0x35, 0xe9,
-	0x06, 0x64, 0xd8, 0x01, 0x3d, 0x34, 0x1d, 0x62, 0xb5, 0xb8, 0xd3, 0xf3, 0xaf, 0x80, 0xb3, 0x46,
-	0x5a, 0x10, 0x6b, 0x8a, 0xa6, 0x53, 0xb8, 0xf4, 0xbf, 0xd5, 0xd6, 0x84, 0xcb, 0x83, 0xed, 0xe4,
-	0xf9, 0x6e, 0x81, 0x0d, 0x57, 0x86, 0x16, 0x50, 0x36, 0xf5, 0x5b, 0x5f, 0xed, 0x3f, 0x6c, 0x7d,
-	0xf5, 0x5f, 0x69, 0x91, 0x65, 0x82, 0x8c, 0x78, 0xae, 0x86, 0x88, 0x6b, 0xe4, 0x70, 0x2e, 0x57,
-	0xd7, 0xc8, 0xc1, 0x3c, 0xfe, 0x7f, 0x90, 0xc3, 0xc4, 0x8e, 0x21, 0x93, 0x12, 0x99, 0xc1, 0xc4,
-	0xee, 0xe3, 0x74, 0x13, 0xf2, 0xc3, 0x5a, 0x2b, 0xef, 0x44, 0x6a, 0x81, 0x76, 0xd6, 0x5a, 0xa0,
-	0xdb, 0xf0, 0x8a, 0x3a, 0xe7, 0xfd, 0x36, 0x5c, 0x24, 0x9f, 0xf3, 0xdd, 0xe3, 0xef, 0xc3, 0xb5,
-	0xe3, 0x57, 0x51, 0xa6, 0x7c, 0x00, 0x49, 0x79, 0x27, 0xd1, 0xc6, 0xbe, 0x93, 0x48, 0xbe, 0x58,
-	0x90, 0xfa, 0x49, 0xf2, 0x9c, 0x0d, 0xf8, 0x5e, 0x24, 0x7a, 0x82, 0x05, 0x94, 0xee, 0x1f, 0xc1,
-	0x74, 0x57, 0x52, 0x94, 0xf6, 0xcb, 0x23, 0x24, 0x79, 0x5f, 0x82, 0xe2, 0xd3, 0x3f, 0x4b, 0x42,
-	0xae, 0x21, 0xe6, 0xea, 0x96, 0x67, 0xb9, 0x98, 0x63, 0x8f, 0xa1, 0xff, 0x8f, 0xd6, 0x68, 0x19,
-	0x26, 0xfe, 0x21, 0x50, 0x7d, 0x41, 0x38, 0x27, 0x63, 0x85, 0x89, 0x52, 0xe8, 0x27, 0x08, 0xb3,
-	0x9f, 0x04, 0xda, 0x8e, 0xeb, 0x70, 0x75, 0x7d, 0xb9, 0xe8, 0xcf, 0x46, 0x9e, 0x94, 0x5d, 0x87,
-	0x8b, 0x52, 0x3b, 0xf4, 0xb6, 0xe6, 0x07, 0xec, 0xe0, 0xeb, 0xd9, 0x47, 0x70, 0x8d, 0xb5, 0x2d,
-	0x76, 0x20, 0x1f, 0x94, 0xfc, 0xd0, 0x31, 0x5d, 0x87, 0x35, 0xf1, 0x81, 0xd5, 0x73, 0xa8, 0xa7,
-	0x82, 0x77, 0x31, 0xc0, 0xa8, 0x30, 0xbb, 0xdf, 0x47, 0xa0, 0x75, 0xb8, 0x3a, 0x24, 0xc1, 0xa6,
-	0x87, 0x44, 0x7a, 0xce, 0xef, 0xc6, 0xae, 0x0c, 0xb0, 0x57, 0xd4, 0x34, 0x7a, 0x17, 0xf2, 0xcc,
-	0xd9, 0x27, 0xd8, 0xf6, 0x2b, 0x1e, 0x33, 0x23, 0x15, 0x6d, 0x5a, 0xb2, 0x5e, 0xf2, 0xe7, 0x65,
-	0xe1, 0x63, 0xdf, 0x09, 0xab, 0xdb, 0x1a, 0x5c, 0x72, 0x1d, 0xc6, 0xfa, 0x8c, 0xae, 0xf5, 0xd4,
-	0x71, 0xbb, 0xae, 0x6c, 0x3d, 0x92, 0xc6, 0x05, 0x7f, 0xd2, 0xe7, 0xba, 0xef, 0x4f, 0xa1, 0x2d,
-	0xb8, 0xe0, 0x3a, 0x24, 0xe2, 0x47, 0xb9, 0x6d, 0xb2, 0x05, 0x39, 0xad, 0x41, 0x5a, 0x70, 0x1d,
-	0x12, 0x4d, 0x40, 0x4f, 0x30, 0x7a, 0x03, 0xfa, 0x7b, 0x65, 0xda, 0xb8, 0x6d, 0x1d, 0xa9, 0xe6,
-	0x24, 0x1b, 0x92, 0x2b, 0x82, 0xaa, 0xff, 0x52, 0x83, 0xec, 0x26, 0x26, 0x98, 0x39, 0xac, 0x4c,
-	0x09, 0x17, 0xdd, 0xeb, 0x0e, 0xa4, 0xe5, 0xda, 0x66, 0x47, 0xc4, 0xc5, 0x18, 0x49, 0x70, 0x20,
-	0x98, 0x8c, 0x39, 0x16, 0x12, 0x18, 0xba, 0x07, 0x10, 0xda, 0x16, 0x34, 0x26, 0x63, 0xdd, 0xd2,
-	0x23, 0xec, 0xfa, 0x57, 0x1a, 0x5c, 0xa9, 0xf6, 0x30, 0xe1, 0x3b, 0xd4, 0x6d, 0x32, 0x4e, 0x49,
-	0x3f, 0xc4, 0x84, 0xe9, 0xb8, 0x27, 0x0e, 0x51, 0x0b, 0xc7, 0x7b, 0x94, 0x6c, 0x40, 0x56, 0x2d,
-	0xca, 0xeb, 0x90, 0x6d, 0xf9, 0xd9, 0x21, 0xc0, 0xf9, 0x41, 0x9b, 0x51, 0x54, 0x05, 0x1b, 0x3c,
-	0xca, 0xc9, 0xb3, 0xa5, 0xe9, 0xc8, 0x6f, 0x02, 0x53, 0xea, 0x61, 0x41, 0xfd, 0x26, 0xf0, 0xda,
-	0xc0, 0x9b, 0xa9, 0x1f, 0x5a, 0xd1, 0x57, 0xd1, 0xb5, 0x3f, 0x4e, 0x43, 0xfa, 0xe3, 0x2e, 0xf6,
-	0x8e, 0x1a, 0xd8, 0xeb, 0x39, 0x2d, 0x8c, 0x3e, 0xd7, 0x60, 0x7e, 0xb0, 0x83, 0x40, 0x23, 0xfc,
-	0x74, 0x72, 0x42, 0x5f, 0xb3, 0xb8, 0x7e, 0x16, 0x56, 0x95, 0x89, 0x3e, 0x1b, 0x7a, 0x86, 0xfa,
-	0xe6, 0xb8, 0xc5, 0x5f, 0x69, 0xf1, 0xee, 0xd8, 0x7c, 0xbe, 0x0a, 0xef, 0x68, 0xe8, 0x47, 0xda,
-	0xf0, 0xdb, 0xf8, 0xb7, 0xc6, 0xaf, 0xdb, 0x4a, 0x91, 0xf7, 0xce, 0xc0, 0xa9, 0xbc, 0x21, 0x76,
-	0x66, 0xb0, 0x76, 0xa2, 0x71, 0xe4, 0xc5, 0xbb, 0x84, 0x51, 0x76, 0xe6, 0xc4, 0x52, 0xfd, 0x63,
-	0x2d, 0x6c, 0xa7, 0x63, 0x05, 0x10, 0x7d, 0xfb, 0x74, 0xa1, 0x2f, 0x28, 0xcf, 0x8b, 0x1f, 0x9c,
-	0x95, 0x5d, 0xe9, 0x15, 0xdb, 0x2c, 0x75, 0xbb, 0x18, 0x67, 0xb3, 0x62, 0xb5, 0x76, 0xac, 0xcd,
-	0x8a, 0x17, 0xd1, 0xd2, 0xef, 0x12, 0xbf, 0x7f, 0xb6, 0xa4, 0x7d, 0xf9, 0x6c, 0x49, 0xfb, 0xdb,
-	0xb3, 0x25, 0xed, 0x8b, 0xe7, 0x4b, 0x13, 0x5f, 0x3e, 0x5f, 0x9a, 0xf8, 0xf3, 0xf3, 0xa5, 0x09,
-	0xb8, 0xd9, 0xa2, 0xee, 0xa9, 0x82, 0x4b, 0xe0, 0xe7, 0x3c, 0x8f, 0x72, 0x5a, 0xd7, 0x1e, 0xed,
-	0xec, 0x3b, 0xfc, 0xa0, 0xdb, 0x14, 0xc0, 0x95, 0x16, 0x65, 0x2e, 0x65, 0x2b, 0x9e, 0xc8, 0xb2,
-	0xd8, 0x5b, 0xe9, 0xad, 0x85, 0x9f, 0xad, 0x03, 0xcb, 0x21, 0x6c, 0xe5, 0xb4, 0xbf, 0x16, 0x78,
-	0x5f, 0x7e, 0xf4, 0x56, 0x7f, 0x96, 0x48, 0xd6, 0xcb, 0xe5, 0xc6, 0xcf, 0x13, 0x85, 0x7a, 0xa0,
-	0x4d, 0x59, 0x68, 0x53, 0x0e, 0xb5, 0x91, 0x3a, 0x14, 0x77, 0x57, 0xff, 0xd0, 0x87, 0x3c, 0x16,
-	0x90, 0xc7, 0x21, 0xe4, 0xb1, 0x84, 0x3c, 0xde, 0x5d, 0x7d, 0x96, 0xb8, 0x75, 0x1a, 0xe4, 0xf1,
-	0x66, 0xbd, 0x74, 0x1f, 0x73, 0x4b, 0x74, 0x38, 0xff, 0x48, 0xdc, 0x0c, 0xe0, 0xeb, 0xeb, 0x02,
-	0x2f, 0xfe, 0x55, 0x0c, 0xeb, 0xeb, 0x92, 0x63, 0x7d, 0x7d, 0x77, 0xb5, 0x39, 0x2d, 0xff, 0x42,
-	0xe0, 0x6b, 0xff, 0x0e, 0x00, 0x00, 0xff, 0xff, 0x59, 0xdb, 0x10, 0x7f, 0x03, 0x21, 0x00, 0x00,
+func (m *EventValidatorStateChange) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *EventValidatorStateChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_EventValidatorStateChange.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 *EventValidatorStateChange) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_EventValidatorStateChange.Merge(m, src)
+}
+func (m *EventValidatorStateChange) XXX_Size() int {
+	return m.Size()
+}
+func (m *EventValidatorStateChange) XXX_DiscardUnknown() {
+	xxx_messageInfo_EventValidatorStateChange.DiscardUnknown(m)
 }
 
-// Reference imports to suppress errors if they are not otherwise used.
-var _ context.Context
-var _ grpc.ClientConn
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the grpc package it is being compiled against.
-const _ = grpc.SupportPackageIsVersion4
+var xxx_messageInfo_EventValidatorStateChange proto.InternalMessageInfo
 
-// QueryServiceClient is the client API for QueryService service.
-//
-// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
-type QueryServiceClient interface {
-	// Queries for information about a specific validator.
-	GetValidatorInfo(ctx context.Context, in *GetValidatorInfoRequest, opts ...grpc.CallOption) (*GetValidatorInfoResponse, error)
-	// Queries the current validator set, with filtering.
-	ValidatorInfo(ctx context.Context, in *ValidatorInfoRequest, opts ...grpc.CallOption) (QueryService_ValidatorInfoClient, error)
-	ValidatorStatus(ctx context.Context, in *ValidatorStatusRequest, opts ...grpc.CallOption) (*ValidatorStatusResponse, error)
-	ValidatorPenalty(ctx context.Context, in *ValidatorPenaltyRequest, opts ...grpc.CallOption) (*ValidatorPenaltyResponse, error)
-	CurrentValidatorRate(ctx context.Context, in *CurrentValidatorRateRequest, opts ...grpc.CallOption) (*CurrentValidatorRateResponse, error)
-	ValidatorUptime(ctx context.Context, in *ValidatorUptimeRequest, opts ...grpc.CallOption) (*ValidatorUptimeResponse, error)
+func (m *EventValidatorStateChange) GetIdentityKey() *v1.IdentityKey {
+	if m != nil {
+		return m.IdentityKey
+	}
+	return nil
 }
 
-type queryServiceClient struct {
-	cc grpc1.ClientConn
+func (m *EventValidatorStateChange) GetState() *ValidatorState {
+	if m != nil {
+		return m.State
+	}
+	return nil
 }
 
-func NewQueryServiceClient(cc grpc1.ClientConn) QueryServiceClient {
-	return &queryServiceClient{cc}
+type EventValidatorVotingPowerChange struct {
+	// The validator's identity key.
+	IdentityKey *v1.IdentityKey `protobuf:"bytes,1,opt,name=identity_key,json=identityKey,proto3" json:"identity_key,omitempty"`
+	// The new voting power of the validator.
+	VotingPower *v11.Amount `protobuf:"bytes,2,opt,name=voting_power,json=votingPower,proto3" json:"voting_power,omitempty"`
 }
 
-func (c *queryServiceClient) GetValidatorInfo(ctx context.Context, in *GetValidatorInfoRequest, opts ...grpc.CallOption) (*GetValidatorInfoResponse, error) {
-	out := new(GetValidatorInfoResponse)
-	err := c.cc.Invoke(ctx, "/penumbra.core.component.stake.v1.QueryService/GetValidatorInfo", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (m *EventValidatorVotingPowerChange) Reset()         { *m = EventValidatorVotingPowerChange{} }
+func (m *EventValidatorVotingPowerChange) String() string { return proto.CompactTextString(m) }
+func (*EventValidatorVotingPowerChange) ProtoMessage()    {}
+func (*EventValidatorVotingPowerChange) Descriptor() ([]byte, []int) {
+	return fileDescriptor_061b0086577193ed, []int{36}
+}
+func (m *EventValidatorVotingPowerChange) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *EventValidatorVotingPowerChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_EventValidatorVotingPowerChange.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
 	}
-	return out, nil
+}
+func (m *EventValidatorVotingPowerChange) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_EventValidatorVotingPowerChange.Merge(m, src)
+}
+func (m *EventValidatorVotingPowerChange) XXX_Size() int {
+	return m.Size()
+}
+func (m *EventValidatorVotingPowerChange) XXX_DiscardUnknown() {
+	xxx_messageInfo_EventValidatorVotingPowerChange.DiscardUnknown(m)
 }
 
-func (c *queryServiceClient) ValidatorInfo(ctx context.Context, in *ValidatorInfoRequest, opts ...grpc.CallOption) (QueryService_ValidatorInfoClient, error) {
-	stream, err := c.cc.NewStream(ctx, &_QueryService_serviceDesc.Streams[0], "/penumbra.core.component.stake.v1.QueryService/ValidatorInfo", opts...)
-	if err != nil {
-		return nil, err
-	}
-	x := &queryServiceValidatorInfoClient{stream}
-	if err := x.ClientStream.SendMsg(in); err != nil {
-		return nil, err
-	}
-	if err := x.ClientStream.CloseSend(); err != nil {
-		return nil, err
+var xxx_messageInfo_EventValidatorVotingPowerChange proto.InternalMessageInfo
+
+func (m *EventValidatorVotingPowerChange) GetIdentityKey() *v1.IdentityKey {
+	if m != nil {
+		return m.IdentityKey
 	}
-	return x, nil
+	return nil
 }
 
-type QueryService_ValidatorInfoClient interface {
-	Recv() (*ValidatorInfoResponse, error)
-	grpc.ClientStream
+func (m *EventValidatorVotingPowerChange) GetVotingPower() *v11.Amount {
+	if m != nil {
+		return m.VotingPower
+	}
+	return nil
 }
 
-type queryServiceValidatorInfoClient struct {
-	grpc.ClientStream
+type EventValidatorBondingStateChange struct {
+	// The validator's identity key.
+	IdentityKey *v1.IdentityKey `protobuf:"bytes,1,opt,name=identity_key,json=identityKey,proto3" json:"identity_key,omitempty"`
+	// The new bonding state of the validator.
+	BondingState *BondingState `protobuf:"bytes,2,opt,name=bonding_state,json=bondingState,proto3" json:"bonding_state,omitempty"`
 }
 
-func (x *queryServiceValidatorInfoClient) Recv() (*ValidatorInfoResponse, error) {
-	m := new(ValidatorInfoResponse)
-	if err := x.ClientStream.RecvMsg(m); err != nil {
-		return nil, err
+func (m *EventValidatorBondingStateChange) Reset()         { *m = EventValidatorBondingStateChange{} }
+func (m *EventValidatorBondingStateChange) String() string { return proto.CompactTextString(m) }
+func (*EventValidatorBondingStateChange) ProtoMessage()    {}
+func (*EventValidatorBondingStateChange) Descriptor() ([]byte, []int) {
+	return fileDescriptor_061b0086577193ed, []int{37}
+}
+func (m *EventValidatorBondingStateChange) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *EventValidatorBondingStateChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_EventValidatorBondingStateChange.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
 	}
-	return m, nil
+}
+func (m *EventValidatorBondingStateChange) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_EventValidatorBondingStateChange.Merge(m, src)
+}
+func (m *EventValidatorBondingStateChange) XXX_Size() int {
+	return m.Size()
+}
+func (m *EventValidatorBondingStateChange) XXX_DiscardUnknown() {
+	xxx_messageInfo_EventValidatorBondingStateChange.DiscardUnknown(m)
 }
 
-func (c *queryServiceClient) ValidatorStatus(ctx context.Context, in *ValidatorStatusRequest, opts ...grpc.CallOption) (*ValidatorStatusResponse, error) {
-	out := new(ValidatorStatusResponse)
-	err := c.cc.Invoke(ctx, "/penumbra.core.component.stake.v1.QueryService/ValidatorStatus", in, out, opts...)
-	if err != nil {
-		return nil, err
+var xxx_messageInfo_EventValidatorBondingStateChange proto.InternalMessageInfo
+
+func (m *EventValidatorBondingStateChange) GetIdentityKey() *v1.IdentityKey {
+	if m != nil {
+		return m.IdentityKey
 	}
-	return out, nil
+	return nil
 }
 
-func (c *queryServiceClient) ValidatorPenalty(ctx context.Context, in *ValidatorPenaltyRequest, opts ...grpc.CallOption) (*ValidatorPenaltyResponse, error) {
-	out := new(ValidatorPenaltyResponse)
-	err := c.cc.Invoke(ctx, "/penumbra.core.component.stake.v1.QueryService/ValidatorPenalty", in, out, opts...)
-	if err != nil {
-		return nil, err
+func (m *EventValidatorBondingStateChange) GetBondingState() *BondingState {
+	if m != nil {
+		return m.BondingState
 	}
-	return out, nil
+	return nil
 }
 
-func (c *queryServiceClient) CurrentValidatorRate(ctx context.Context, in *CurrentValidatorRateRequest, opts ...grpc.CallOption) (*CurrentValidatorRateResponse, error) {
-	out := new(CurrentValidatorRateResponse)
-	err := c.cc.Invoke(ctx, "/penumbra.core.component.stake.v1.QueryService/CurrentValidatorRate", in, out, opts...)
-	if err != nil {
-		return nil, err
+type EventRateDataChange struct {
+	// The validator's identity key.
+	IdentityKey *v1.IdentityKey `protobuf:"bytes,1,opt,name=identity_key,json=identityKey,proto3" json:"identity_key,omitempty"`
+	// The new rate data.
+	RateData *RateData `protobuf:"bytes,2,opt,name=rate_data,json=rateData,proto3" json:"rate_data,omitempty"`
+}
+
+func (m *EventRateDataChange) Reset()         { *m = EventRateDataChange{} }
+func (m *EventRateDataChange) String() string { return proto.CompactTextString(m) }
+func (*EventRateDataChange) ProtoMessage()    {}
+func (*EventRateDataChange) Descriptor() ([]byte, []int) {
+	return fileDescriptor_061b0086577193ed, []int{38}
+}
+func (m *EventRateDataChange) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *EventRateDataChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_EventRateDataChange.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
 	}
-	return out, nil
+}
+func (m *EventRateDataChange) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_EventRateDataChange.Merge(m, src)
+}
+func (m *EventRateDataChange) XXX_Size() int {
+	return m.Size()
+}
+func (m *EventRateDataChange) XXX_DiscardUnknown() {
+	xxx_messageInfo_EventRateDataChange.DiscardUnknown(m)
 }
 
-func (c *queryServiceClient) ValidatorUptime(ctx context.Context, in *ValidatorUptimeRequest, opts ...grpc.CallOption) (*ValidatorUptimeResponse, error) {
-	out := new(ValidatorUptimeResponse)
-	err := c.cc.Invoke(ctx, "/penumbra.core.component.stake.v1.QueryService/ValidatorUptime", in, out, opts...)
-	if err != nil {
-		return nil, err
+var xxx_messageInfo_EventRateDataChange proto.InternalMessageInfo
+
+func (m *EventRateDataChange) GetIdentityKey() *v1.IdentityKey {
+	if m != nil {
+		return m.IdentityKey
 	}
-	return out, nil
+	return nil
 }
 
-// QueryServiceServer is the server API for QueryService service.
-type QueryServiceServer interface {
-	// Queries for information about a specific validator.
-	GetValidatorInfo(context.Context, *GetValidatorInfoRequest) (*GetValidatorInfoResponse, error)
-	// Queries the current validator set, with filtering.
-	ValidatorInfo(*ValidatorInfoRequest, QueryService_ValidatorInfoServer) error
-	ValidatorStatus(context.Context, *ValidatorStatusRequest) (*ValidatorStatusResponse, error)
-	ValidatorPenalty(context.Context, *ValidatorPenaltyRequest) (*ValidatorPenaltyResponse, error)
-	CurrentValidatorRate(context.Context, *CurrentValidatorRateRequest) (*CurrentValidatorRateResponse, error)
-	ValidatorUptime(context.Context, *ValidatorUptimeRequest) (*ValidatorUptimeResponse, error)
+func (m *EventRateDataChange) GetRateData() *RateData {
+	if m != nil {
+		return m.RateData
+	}
+	return nil
 }
 
-// UnimplementedQueryServiceServer can be embedded to have forward compatible implementations.
-type UnimplementedQueryServiceServer struct {
+type EventValidatorDefinitionUpload struct {
+	// The validator definition.
+	Validator *Validator `protobuf:"bytes,1,opt,name=validator,proto3" json:"validator,omitempty"`
 }
 
-func (*UnimplementedQueryServiceServer) GetValidatorInfo(ctx context.Context, req *GetValidatorInfoRequest) (*GetValidatorInfoResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method GetValidatorInfo not implemented")
+func (m *EventValidatorDefinitionUpload) Reset()         { *m = EventValidatorDefinitionUpload{} }
+func (m *EventValidatorDefinitionUpload) String() string { return proto.CompactTextString(m) }
+func (*EventValidatorDefinitionUpload) ProtoMessage()    {}
+func (*EventValidatorDefinitionUpload) Descriptor() ([]byte, []int) {
+	return fileDescriptor_061b0086577193ed, []int{39}
 }
-func (*UnimplementedQueryServiceServer) ValidatorInfo(req *ValidatorInfoRequest, srv QueryService_ValidatorInfoServer) error {
-	return status.Errorf(codes.Unimplemented, "method ValidatorInfo not implemented")
+func (m *EventValidatorDefinitionUpload) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
 }
-func (*UnimplementedQueryServiceServer) ValidatorStatus(ctx context.Context, req *ValidatorStatusRequest) (*ValidatorStatusResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method ValidatorStatus not implemented")
+func (m *EventValidatorDefinitionUpload) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_EventValidatorDefinitionUpload.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 (*UnimplementedQueryServiceServer) ValidatorPenalty(ctx context.Context, req *ValidatorPenaltyRequest) (*ValidatorPenaltyResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method ValidatorPenalty not implemented")
+func (m *EventValidatorDefinitionUpload) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_EventValidatorDefinitionUpload.Merge(m, src)
 }
-func (*UnimplementedQueryServiceServer) CurrentValidatorRate(ctx context.Context, req *CurrentValidatorRateRequest) (*CurrentValidatorRateResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method CurrentValidatorRate not implemented")
+func (m *EventValidatorDefinitionUpload) XXX_Size() int {
+	return m.Size()
 }
-func (*UnimplementedQueryServiceServer) ValidatorUptime(ctx context.Context, req *ValidatorUptimeRequest) (*ValidatorUptimeResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method ValidatorUptime not implemented")
+func (m *EventValidatorDefinitionUpload) XXX_DiscardUnknown() {
+	xxx_messageInfo_EventValidatorDefinitionUpload.DiscardUnknown(m)
 }
 
-func RegisterQueryServiceServer(s grpc1.Server, srv QueryServiceServer) {
-	s.RegisterService(&_QueryService_serviceDesc, srv)
-}
+var xxx_messageInfo_EventValidatorDefinitionUpload proto.InternalMessageInfo
 
-func _QueryService_GetValidatorInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(GetValidatorInfoRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(QueryServiceServer).GetValidatorInfo(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/penumbra.core.component.stake.v1.QueryService/GetValidatorInfo",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(QueryServiceServer).GetValidatorInfo(ctx, req.(*GetValidatorInfoRequest))
+func (m *EventValidatorDefinitionUpload) GetValidator() *Validator {
+	if m != nil {
+		return m.Validator
 	}
-	return interceptor(ctx, in, info, handler)
+	return nil
 }
 
-func _QueryService_ValidatorInfo_Handler(srv interface{}, stream grpc.ServerStream) error {
-	m := new(ValidatorInfoRequest)
-	if err := stream.RecvMsg(m); err != nil {
-		return err
-	}
-	return srv.(QueryServiceServer).ValidatorInfo(m, &queryServiceValidatorInfoServer{stream})
+type EventValidatorMissedBlock struct {
+	// The validator's identity key.
+	IdentityKey *v1.IdentityKey `protobuf:"bytes,1,opt,name=identity_key,json=identityKey,proto3" json:"identity_key,omitempty"`
 }
 
-type QueryService_ValidatorInfoServer interface {
-	Send(*ValidatorInfoResponse) error
-	grpc.ServerStream
+func (m *EventValidatorMissedBlock) Reset()         { *m = EventValidatorMissedBlock{} }
+func (m *EventValidatorMissedBlock) String() string { return proto.CompactTextString(m) }
+func (*EventValidatorMissedBlock) ProtoMessage()    {}
+func (*EventValidatorMissedBlock) Descriptor() ([]byte, []int) {
+	return fileDescriptor_061b0086577193ed, []int{40}
+}
+func (m *EventValidatorMissedBlock) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *EventValidatorMissedBlock) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_EventValidatorMissedBlock.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 *EventValidatorMissedBlock) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_EventValidatorMissedBlock.Merge(m, src)
+}
+func (m *EventValidatorMissedBlock) XXX_Size() int {
+	return m.Size()
+}
+func (m *EventValidatorMissedBlock) XXX_DiscardUnknown() {
+	xxx_messageInfo_EventValidatorMissedBlock.DiscardUnknown(m)
 }
 
-type queryServiceValidatorInfoServer struct {
-	grpc.ServerStream
+var xxx_messageInfo_EventValidatorMissedBlock proto.InternalMessageInfo
+
+func (m *EventValidatorMissedBlock) GetIdentityKey() *v1.IdentityKey {
+	if m != nil {
+		return m.IdentityKey
+	}
+	return nil
 }
 
-func (x *queryServiceValidatorInfoServer) Send(m *ValidatorInfoResponse) error {
-	return x.ServerStream.SendMsg(m)
+type EventDelegate struct {
+	// The validator's identity key.
+	IdentityKey *v1.IdentityKey `protobuf:"bytes,1,opt,name=identity_key,json=identityKey,proto3" json:"identity_key,omitempty"`
+	// The amount of stake delegated, in the staking token.
+	Amount *v11.Amount `protobuf:"bytes,3,opt,name=amount,proto3" json:"amount,omitempty"`
 }
 
-func _QueryService_ValidatorStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(ValidatorStatusRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(QueryServiceServer).ValidatorStatus(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/penumbra.core.component.stake.v1.QueryService/ValidatorStatus",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(QueryServiceServer).ValidatorStatus(ctx, req.(*ValidatorStatusRequest))
+func (m *EventDelegate) Reset()         { *m = EventDelegate{} }
+func (m *EventDelegate) String() string { return proto.CompactTextString(m) }
+func (*EventDelegate) ProtoMessage()    {}
+func (*EventDelegate) Descriptor() ([]byte, []int) {
+	return fileDescriptor_061b0086577193ed, []int{41}
+}
+func (m *EventDelegate) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *EventDelegate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_EventDelegate.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
 	}
-	return interceptor(ctx, in, info, handler)
+}
+func (m *EventDelegate) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_EventDelegate.Merge(m, src)
+}
+func (m *EventDelegate) XXX_Size() int {
+	return m.Size()
+}
+func (m *EventDelegate) XXX_DiscardUnknown() {
+	xxx_messageInfo_EventDelegate.DiscardUnknown(m)
 }
 
-func _QueryService_ValidatorPenalty_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(ValidatorPenaltyRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(QueryServiceServer).ValidatorPenalty(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/penumbra.core.component.stake.v1.QueryService/ValidatorPenalty",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(QueryServiceServer).ValidatorPenalty(ctx, req.(*ValidatorPenaltyRequest))
+var xxx_messageInfo_EventDelegate proto.InternalMessageInfo
+
+func (m *EventDelegate) GetIdentityKey() *v1.IdentityKey {
+	if m != nil {
+		return m.IdentityKey
 	}
-	return interceptor(ctx, in, info, handler)
+	return nil
 }
 
-func _QueryService_CurrentValidatorRate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(CurrentValidatorRateRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(QueryServiceServer).CurrentValidatorRate(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/penumbra.core.component.stake.v1.QueryService/CurrentValidatorRate",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(QueryServiceServer).CurrentValidatorRate(ctx, req.(*CurrentValidatorRateRequest))
+func (m *EventDelegate) GetAmount() *v11.Amount {
+	if m != nil {
+		return m.Amount
 	}
-	return interceptor(ctx, in, info, handler)
+	return nil
 }
 
-func _QueryService_ValidatorUptime_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(ValidatorUptimeRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(QueryServiceServer).ValidatorUptime(ctx, in)
+type EventUndelegate struct {
+	// The validator's identity key.
+	IdentityKey *v1.IdentityKey `protobuf:"bytes,1,opt,name=identity_key,json=identityKey,proto3" json:"identity_key,omitempty"`
+	// The amount of stake undelegated, in the staking token.
+	Amount *v11.Amount `protobuf:"bytes,3,opt,name=amount,proto3" json:"amount,omitempty"`
+}
+
+func (m *EventUndelegate) Reset()         { *m = EventUndelegate{} }
+func (m *EventUndelegate) String() string { return proto.CompactTextString(m) }
+func (*EventUndelegate) ProtoMessage()    {}
+func (*EventUndelegate) Descriptor() ([]byte, []int) {
+	return fileDescriptor_061b0086577193ed, []int{42}
+}
+func (m *EventUndelegate) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *EventUndelegate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_EventUndelegate.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
 	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/penumbra.core.component.stake.v1.QueryService/ValidatorUptime",
+}
+func (m *EventUndelegate) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_EventUndelegate.Merge(m, src)
+}
+func (m *EventUndelegate) XXX_Size() int {
+	return m.Size()
+}
+func (m *EventUndelegate) XXX_DiscardUnknown() {
+	xxx_messageInfo_EventUndelegate.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EventUndelegate proto.InternalMessageInfo
+
+func (m *EventUndelegate) GetIdentityKey() *v1.IdentityKey {
+	if m != nil {
+		return m.IdentityKey
 	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(QueryServiceServer).ValidatorUptime(ctx, req.(*ValidatorUptimeRequest))
+	return nil
+}
+
+func (m *EventUndelegate) GetAmount() *v11.Amount {
+	if m != nil {
+		return m.Amount
 	}
-	return interceptor(ctx, in, info, handler)
+	return nil
 }
 
-var _QueryService_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "penumbra.core.component.stake.v1.QueryService",
-	HandlerType: (*QueryServiceServer)(nil),
-	Methods: []grpc.MethodDesc{
-		{
-			MethodName: "GetValidatorInfo",
-			Handler:    _QueryService_GetValidatorInfo_Handler,
-		},
-		{
-			MethodName: "ValidatorStatus",
-			Handler:    _QueryService_ValidatorStatus_Handler,
-		},
-		{
-			MethodName: "ValidatorPenalty",
-			Handler:    _QueryService_ValidatorPenalty_Handler,
-		},
-		{
-			MethodName: "CurrentValidatorRate",
-			Handler:    _QueryService_CurrentValidatorRate_Handler,
-		},
-		{
-			MethodName: "ValidatorUptime",
-			Handler:    _QueryService_ValidatorUptime_Handler,
-		},
-	},
-	Streams: []grpc.StreamDesc{
-		{
-			StreamName:    "ValidatorInfo",
-			Handler:       _QueryService_ValidatorInfo_Handler,
-			ServerStreams: true,
-		},
-	},
-	Metadata: "penumbra/core/component/stake/v1/stake.proto",
+// Indicates a slashing penalty was applied to a validator's reward rates.
+type EventSlashingPenaltyApplied struct {
+	// The validator's identity key.
+	IdentityKey *v1.IdentityKey `protobuf:"bytes,1,opt,name=identity_key,json=identityKey,proto3" json:"identity_key,omitempty"`
+	// The epoch in which the penalty was applied.
+	EpochIndex uint64 `protobuf:"varint,2,opt,name=epoch_index,json=epochIndex,proto3" json:"epoch_index,omitempty"`
+	// The penalty amount after slashing.
+	NewPenalty *Penalty `protobuf:"bytes,3,opt,name=new_penalty,json=newPenalty,proto3" json:"new_penalty,omitempty"`
 }
 
-func (m *ZKUndelegateClaimProof) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
+func (m *EventSlashingPenaltyApplied) Reset()         { *m = EventSlashingPenaltyApplied{} }
+func (m *EventSlashingPenaltyApplied) String() string { return proto.CompactTextString(m) }
+func (*EventSlashingPenaltyApplied) ProtoMessage()    {}
+func (*EventSlashingPenaltyApplied) Descriptor() ([]byte, []int) {
+	return fileDescriptor_061b0086577193ed, []int{43}
+}
+func (m *EventSlashingPenaltyApplied) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *EventSlashingPenaltyApplied) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_EventSlashingPenaltyApplied.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
 	}
-	return dAtA[:n], nil
 }
-
-func (m *ZKUndelegateClaimProof) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
+func (m *EventSlashingPenaltyApplied) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_EventSlashingPenaltyApplied.Merge(m, src)
+}
+func (m *EventSlashingPenaltyApplied) XXX_Size() int {
+	return m.Size()
+}
+func (m *EventSlashingPenaltyApplied) XXX_DiscardUnknown() {
+	xxx_messageInfo_EventSlashingPenaltyApplied.DiscardUnknown(m)
 }
 
-func (m *ZKUndelegateClaimProof) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if len(m.Inner) > 0 {
-		i -= len(m.Inner)
-		copy(dAtA[i:], m.Inner)
-		i = encodeVarintStake(dAtA, i, uint64(len(m.Inner)))
-		i--
-		dAtA[i] = 0xa
+var xxx_messageInfo_EventSlashingPenaltyApplied proto.InternalMessageInfo
+
+func (m *EventSlashingPenaltyApplied) GetIdentityKey() *v1.IdentityKey {
+	if m != nil {
+		return m.IdentityKey
 	}
-	return len(dAtA) - i, nil
+	return nil
 }
 
-func (m *Validator) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
+func (m *EventSlashingPenaltyApplied) GetEpochIndex() uint64 {
+	if m != nil {
+		return m.EpochIndex
 	}
-	return dAtA[:n], nil
+	return 0
 }
 
-func (m *Validator) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
+func (m *EventSlashingPenaltyApplied) GetNewPenalty() *Penalty {
+	if m != nil {
+		return m.NewPenalty
+	}
+	return nil
 }
 
-func (m *Validator) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if m.GovernanceKey != nil {
-		{
-			size, err := m.GovernanceKey.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintStake(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x4a
-	}
-	if m.Enabled {
-		i--
-		if m.Enabled {
-			dAtA[i] = 1
-		} else {
-			dAtA[i] = 0
-		}
-		i--
-		dAtA[i] = 0x40
-	}
-	if m.SequenceNumber != 0 {
-		i = encodeVarintStake(dAtA, i, uint64(m.SequenceNumber))
-		i--
-		dAtA[i] = 0x38
-	}
-	if len(m.FundingStreams) > 0 {
-		for iNdEx := len(m.FundingStreams) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.FundingStreams[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintStake(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0x32
-		}
-	}
-	if len(m.Description) > 0 {
-		i -= len(m.Description)
-		copy(dAtA[i:], m.Description)
-		i = encodeVarintStake(dAtA, i, uint64(len(m.Description)))
-		i--
-		dAtA[i] = 0x2a
-	}
-	if len(m.Website) > 0 {
-		i -= len(m.Website)
-		copy(dAtA[i:], m.Website)
-		i = encodeVarintStake(dAtA, i, uint64(len(m.Website)))
-		i--
-		dAtA[i] = 0x22
-	}
-	if len(m.Name) > 0 {
-		i -= len(m.Name)
-		copy(dAtA[i:], m.Name)
-		i = encodeVarintStake(dAtA, i, uint64(len(m.Name)))
-		i--
-		dAtA[i] = 0x1a
-	}
-	if len(m.ConsensusKey) > 0 {
-		i -= len(m.ConsensusKey)
-		copy(dAtA[i:], m.ConsensusKey)
-		i = encodeVarintStake(dAtA, i, uint64(len(m.ConsensusKey)))
-		i--
-		dAtA[i] = 0x12
-	}
-	if m.IdentityKey != nil {
-		{
-			size, err := m.IdentityKey.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintStake(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0xa
+func init() {
+	proto.RegisterEnum("penumbra.core.component.stake.v1.BondingState_BondingStateEnum", BondingState_BondingStateEnum_name, BondingState_BondingStateEnum_value)
+	proto.RegisterEnum("penumbra.core.component.stake.v1.ValidatorState_ValidatorStateEnum", ValidatorState_ValidatorStateEnum_name, ValidatorState_ValidatorStateEnum_value)
+	proto.RegisterType((*ZKUndelegateClaimProof)(nil), "penumbra.core.component.stake.v1.ZKUndelegateClaimProof")
+	proto.RegisterType((*Validator)(nil), "penumbra.core.component.stake.v1.Validator")
+	proto.RegisterType((*ValidatorList)(nil), "penumbra.core.component.stake.v1.ValidatorList")
+	proto.RegisterType((*FundingStream)(nil), "penumbra.core.component.stake.v1.FundingStream")
+	proto.RegisterType((*FundingStream_ToAddress)(nil), "penumbra.core.component.stake.v1.FundingStream.ToAddress")
+	proto.RegisterType((*FundingStream_ToCommunityPool)(nil), "penumbra.core.component.stake.v1.FundingStream.ToCommunityPool")
+	proto.RegisterType((*RateData)(nil), "penumbra.core.component.stake.v1.RateData")
+	proto.RegisterType((*BaseRateData)(nil), "penumbra.core.component.stake.v1.BaseRateData")
+	proto.RegisterType((*ValidatorStatus)(nil), "penumbra.core.component.stake.v1.ValidatorStatus")
+	proto.RegisterType((*BondingState)(nil), "penumbra.core.component.stake.v1.BondingState")
+	proto.RegisterType((*ValidatorState)(nil), "penumbra.core.component.stake.v1.ValidatorState")
+	proto.RegisterType((*ValidatorInfo)(nil), "penumbra.core.component.stake.v1.ValidatorInfo")
+	proto.RegisterType((*ValidatorDefinition)(nil), "penumbra.core.component.stake.v1.ValidatorDefinition")
+	proto.RegisterType((*Delegate)(nil), "penumbra.core.component.stake.v1.Delegate")
+	proto.RegisterType((*Undelegate)(nil), "penumbra.core.component.stake.v1.Undelegate")
+	proto.RegisterType((*UndelegateClaim)(nil), "penumbra.core.component.stake.v1.UndelegateClaim")
+	proto.RegisterType((*UndelegateClaimBody)(nil), "penumbra.core.component.stake.v1.UndelegateClaimBody")
+	proto.RegisterType((*UndelegateClaimPlan)(nil), "penumbra.core.component.stake.v1.UndelegateClaimPlan")
+	proto.RegisterType((*DelegationChanges)(nil), "penumbra.core.component.stake.v1.DelegationChanges")
+	proto.RegisterType((*Uptime)(nil), "penumbra.core.component.stake.v1.Uptime")
+	proto.RegisterType((*CurrentConsensusKeys)(nil), "penumbra.core.component.stake.v1.CurrentConsensusKeys")
+	proto.RegisterType((*Penalty)(nil), "penumbra.core.component.stake.v1.Penalty")
+	proto.RegisterType((*GetValidatorInfoRequest)(nil), "penumbra.core.component.stake.v1.GetValidatorInfoRequest")
+	proto.RegisterType((*GetValidatorInfoResponse)(nil), "penumbra.core.component.stake.v1.GetValidatorInfoResponse")
+	proto.RegisterType((*ValidatorInfoRequest)(nil), "penumbra.core.component.stake.v1.ValidatorInfoRequest")
+	proto.RegisterType((*ValidatorInfoResponse)(nil), "penumbra.core.component.stake.v1.ValidatorInfoResponse")
+	proto.RegisterType((*ValidatorStatusRequest)(nil), "penumbra.core.component.stake.v1.ValidatorStatusRequest")
+	proto.RegisterType((*ValidatorStatusResponse)(nil), "penumbra.core.component.stake.v1.ValidatorStatusResponse")
+	proto.RegisterType((*ValidatorPenaltyRequest)(nil), "penumbra.core.component.stake.v1.ValidatorPenaltyRequest")
+	proto.RegisterType((*ValidatorPenaltyResponse)(nil), "penumbra.core.component.stake.v1.ValidatorPenaltyResponse")
+	proto.RegisterType((*CurrentValidatorRateRequest)(nil), "penumbra.core.component.stake.v1.CurrentValidatorRateRequest")
+	proto.RegisterType((*CurrentValidatorRateResponse)(nil), "penumbra.core.component.stake.v1.CurrentValidatorRateResponse")
+	proto.RegisterType((*ValidatorUptimeRequest)(nil), "penumbra.core.component.stake.v1.ValidatorUptimeRequest")
+	proto.RegisterType((*ValidatorUptimeResponse)(nil), "penumbra.core.component.stake.v1.ValidatorUptimeResponse")
+	proto.RegisterType((*StakeParameters)(nil), "penumbra.core.component.stake.v1.StakeParameters")
+	proto.RegisterType((*GenesisContent)(nil), "penumbra.core.component.stake.v1.GenesisContent")
+	proto.RegisterType((*EventTombstoneValidator)(nil), "penumbra.core.component.stake.v1.EventTombstoneValidator")
+	proto.RegisterType((*EventValidatorStateChange)(nil), "penumbra.core.component.stake.v1.EventValidatorStateChange")
+	proto.RegisterType((*EventValidatorVotingPowerChange)(nil), "penumbra.core.component.stake.v1.EventValidatorVotingPowerChange")
+	proto.RegisterType((*EventValidatorBondingStateChange)(nil), "penumbra.core.component.stake.v1.EventValidatorBondingStateChange")
+	proto.RegisterType((*EventRateDataChange)(nil), "penumbra.core.component.stake.v1.EventRateDataChange")
+	proto.RegisterType((*EventValidatorDefinitionUpload)(nil), "penumbra.core.component.stake.v1.EventValidatorDefinitionUpload")
+	proto.RegisterType((*EventValidatorMissedBlock)(nil), "penumbra.core.component.stake.v1.EventValidatorMissedBlock")
+	proto.RegisterType((*EventDelegate)(nil), "penumbra.core.component.stake.v1.EventDelegate")
+	proto.RegisterType((*EventUndelegate)(nil), "penumbra.core.component.stake.v1.EventUndelegate")
+	proto.RegisterType((*EventSlashingPenaltyApplied)(nil), "penumbra.core.component.stake.v1.EventSlashingPenaltyApplied")
+}
+
+func init() {
+	proto.RegisterFile("penumbra/core/component/stake/v1/stake.proto", fileDescriptor_061b0086577193ed)
+}
+
+var fileDescriptor_061b0086577193ed = []byte{
+	// 2584 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x3a, 0x4d, 0x6c, 0x1b, 0xc7,
+	0xd5, 0xde, 0x15, 0x25, 0x4b, 0x4f, 0xfc, 0x91, 0xc6, 0x7f, 0xb4, 0xe2, 0xc8, 0xcc, 0xda, 0xf9,
+	0xa2, 0x24, 0xfe, 0xa8, 0x48, 0x4d, 0x9b, 0x46, 0x41, 0x93, 0x88, 0x3f, 0x56, 0xe8, 0x1f, 0x99,
+	0x59, 0xca, 0x6a, 0xea, 0x1a, 0xdd, 0x2e, 0xb9, 0x23, 0x69, 0x61, 0xee, 0x2c, 0xb3, 0x33, 0xa4,
+	0x22, 0xf4, 0x96, 0x43, 0x81, 0x00, 0x45, 0x91, 0x4b, 0x81, 0x9e, 0x7a, 0x28, 0xd0, 0x43, 0x73,
+	0x2b, 0xfa, 0x73, 0xec, 0xa5, 0x28, 0x50, 0xf4, 0x94, 0x1e, 0x8a, 0x16, 0xed, 0xa5, 0x70, 0x0e,
+	0x05, 0x0a, 0xa4, 0xd7, 0x5e, 0x8b, 0x99, 0x9d, 0xfd, 0x23, 0x25, 0x93, 0x54, 0xd8, 0xd6, 0x17,
+	0x7b, 0xe7, 0xcd, 0x7b, 0x6f, 0xde, 0x7b, 0xf3, 0xe6, 0xfd, 0x51, 0x70, 0xa3, 0x83, 0x49, 0xd7,
+	0x69, 0x7a, 0xe6, 0x6a, 0xcb, 0xf5, 0xf0, 0x6a, 0xcb, 0x75, 0x3a, 0x2e, 0xc1, 0x84, 0xad, 0x52,
+	0x66, 0x3e, 0xc2, 0xab, 0xbd, 0x35, 0xff, 0xa3, 0xd8, 0xf1, 0x5c, 0xe6, 0xa2, 0x42, 0x80, 0x5d,
+	0xe4, 0xd8, 0xc5, 0x10, 0xbb, 0xe8, 0x23, 0xf5, 0xd6, 0x96, 0xb4, 0x24, 0x3f, 0x93, 0x52, 0xcc,
+	0x38, 0x17, 0xf1, 0xe1, 0x73, 0x59, 0x5a, 0x39, 0xf1, 0xcc, 0x96, 0xc0, 0xa5, 0xad, 0x00, 0xb3,
+	0x90, 0xc4, 0x7c, 0x84, 0x8f, 0x28, 0x47, 0xe0, 0xff, 0x4b, 0x8c, 0xe5, 0x24, 0x06, 0xe9, 0x3a,
+	0x1c, 0x81, 0x74, 0x1d, 0x7f, 0x5f, 0x2b, 0xc2, 0xc5, 0x07, 0xb7, 0xef, 0x13, 0x0b, 0xb7, 0xf1,
+	0xbe, 0xc9, 0x70, 0xb9, 0x6d, 0xda, 0x4e, 0xdd, 0x73, 0xdd, 0x3d, 0x74, 0x1e, 0xa6, 0x6d, 0x42,
+	0xb0, 0x97, 0x57, 0x0a, 0xca, 0x4a, 0x5a, 0xf7, 0x17, 0xda, 0xcf, 0xa6, 0x60, 0x6e, 0xd7, 0x6c,
+	0xdb, 0x96, 0xc9, 0x5c, 0x0f, 0x55, 0x21, 0x6d, 0x5b, 0x98, 0x30, 0x9b, 0x1d, 0x19, 0x8f, 0xf0,
+	0x91, 0x40, 0x9d, 0x5f, 0xd7, 0x8a, 0x49, 0x33, 0x08, 0x71, 0x7a, 0x6b, 0xc5, 0x9a, 0x44, 0xbd,
+	0x8d, 0x8f, 0xf4, 0x79, 0x3b, 0x5a, 0xa0, 0x6b, 0x90, 0x69, 0xb9, 0x84, 0x62, 0x42, 0xbb, 0x54,
+	0xf0, 0x51, 0xc5, 0x91, 0xe9, 0x10, 0xc8, 0x91, 0x10, 0xa4, 0x88, 0xe9, 0xe0, 0xfc, 0x54, 0x41,
+	0x59, 0x99, 0xd3, 0xc5, 0x37, 0xca, 0xc3, 0xd9, 0x43, 0xdc, 0xa4, 0x36, 0xc3, 0xf9, 0x94, 0x00,
+	0x07, 0x4b, 0x54, 0x80, 0x79, 0x0b, 0xd3, 0x96, 0x67, 0x77, 0x98, 0xed, 0x92, 0xfc, 0xb4, 0xd8,
+	0x8d, 0x83, 0x38, 0x2d, 0x26, 0x66, 0xb3, 0x8d, 0xad, 0xfc, 0x6c, 0x41, 0x59, 0x99, 0xd5, 0x83,
+	0x25, 0x7a, 0x0f, 0x72, 0x7b, 0x5d, 0x62, 0xd9, 0x64, 0xdf, 0xa0, 0xcc, 0xc3, 0xa6, 0x43, 0xf3,
+	0x33, 0x85, 0xa9, 0x95, 0xf9, 0xf5, 0xd5, 0xe2, 0xb0, 0xfb, 0x2d, 0xde, 0xf4, 0x09, 0x1b, 0x82,
+	0x4e, 0xcf, 0xee, 0xc5, 0x97, 0x14, 0xbd, 0x00, 0x39, 0x8a, 0xdf, 0xef, 0x62, 0xd2, 0xc2, 0x06,
+	0x67, 0x84, 0xbd, 0xfc, 0xd9, 0x82, 0xb2, 0x92, 0xd1, 0xb3, 0x01, 0x78, 0x5b, 0x40, 0xd1, 0x6d,
+	0xc8, 0xee, 0xbb, 0x3d, 0xec, 0x11, 0x93, 0xa3, 0x72, 0x93, 0xcc, 0x09, 0xd3, 0x5e, 0x3f, 0xc1,
+	0xb4, 0x5b, 0x21, 0x32, 0x37, 0x6e, 0x66, 0x3f, 0xbe, 0xd4, 0x1e, 0x40, 0x26, 0xbc, 0xb2, 0x3b,
+	0x36, 0x65, 0xa8, 0x06, 0xd9, 0x5e, 0x00, 0xe0, 0xcc, 0x69, 0x5e, 0x11, 0xfa, 0x8d, 0x72, 0x71,
+	0x99, 0x90, 0xf2, 0x36, 0x3e, 0xa2, 0xda, 0x9f, 0x54, 0xc8, 0x24, 0x74, 0x46, 0x0f, 0x00, 0x98,
+	0x6b, 0x98, 0x96, 0xe5, 0x61, 0x4a, 0xa5, 0x47, 0xbc, 0x3e, 0xa6, 0xe1, 0x8a, 0x3b, 0xee, 0xa6,
+	0xcf, 0xe0, 0x9d, 0x33, 0xfa, 0x1c, 0x0b, 0x16, 0xc8, 0x81, 0x45, 0xe6, 0x1a, 0x2d, 0xd7, 0x71,
+	0xba, 0x84, 0xfb, 0x5c, 0xc7, 0x75, 0xdb, 0xc2, 0x59, 0xe6, 0xd7, 0xdf, 0x1a, 0xff, 0x88, 0x72,
+	0xc0, 0xa7, 0xee, 0xba, 0xed, 0x77, 0xce, 0xe8, 0x39, 0x96, 0x04, 0x2d, 0xbd, 0x0d, 0x73, 0xa1,
+	0x20, 0xdc, 0x5f, 0xe2, 0x4a, 0xcd, 0xe9, 0xc1, 0x12, 0x5d, 0x86, 0x59, 0xcf, 0x64, 0xd8, 0x68,
+	0x76, 0xa8, 0x10, 0x26, 0xa3, 0x9f, 0xe5, 0xeb, 0x52, 0x87, 0x2e, 0xdd, 0x80, 0x5c, 0xdf, 0x39,
+	0x4f, 0xc0, 0x2e, 0xcd, 0xc3, 0x9c, 0x87, 0x5b, 0x76, 0xc7, 0xc6, 0x84, 0x69, 0x3f, 0x52, 0x61,
+	0x56, 0x37, 0x19, 0xae, 0x98, 0xcc, 0x9c, 0xdc, 0x43, 0x9b, 0xc7, 0x1d, 0xb7, 0x75, 0x60, 0xd8,
+	0xc4, 0xc2, 0x1f, 0x88, 0xe3, 0x53, 0x25, 0x35, 0xaf, 0xe8, 0x20, 0xc0, 0x35, 0x0e, 0x45, 0x75,
+	0xb8, 0x10, 0x79, 0x87, 0x87, 0x0f, 0x4d, 0xcf, 0x32, 0xb8, 0x84, 0xe2, 0x89, 0xcd, 0xaf, 0x5f,
+	0xe9, 0x3b, 0x94, 0xc7, 0x92, 0xde, 0x5a, 0x71, 0xd3, 0x71, 0xbb, 0x84, 0xe9, 0xe7, 0x42, 0x52,
+	0x5d, 0x50, 0x72, 0x0d, 0xd0, 0x0e, 0x5c, 0x8a, 0x38, 0xe2, 0x0f, 0x5a, 0x07, 0x26, 0xd9, 0xc7,
+	0x3e, 0xcf, 0xe9, 0x11, 0x78, 0x46, 0xe2, 0x54, 0x25, 0x2d, 0xe7, 0xaa, 0xfd, 0x46, 0x81, 0x74,
+	0xc9, 0xa4, 0x38, 0x34, 0xd2, 0xd5, 0xa4, 0x76, 0xdc, 0x46, 0xa9, 0x84, 0x66, 0x37, 0x61, 0xa1,
+	0x69, 0x52, 0x9c, 0x50, 0x4a, 0x1d, 0x41, 0x80, 0x2c, 0xa7, 0x8a, 0xe9, 0x73, 0x0b, 0x90, 0xe0,
+	0x93, 0x54, 0x65, 0x6a, 0x04, 0x4e, 0xe2, 0xfc, 0x84, 0x16, 0xbf, 0x52, 0x21, 0x17, 0xbe, 0xce,
+	0x06, 0x33, 0x59, 0x97, 0x4e, 0xea, 0xb6, 0x6f, 0xc2, 0x34, 0x65, 0x91, 0x8e, 0xaf, 0x0c, 0x7f,
+	0x21, 0x09, 0x41, 0xb0, 0xee, 0x93, 0xa3, 0xb7, 0x20, 0xdd, 0x73, 0x19, 0x0f, 0x87, 0x1d, 0xf7,
+	0x10, 0x7b, 0x23, 0x29, 0x3a, 0xef, 0x53, 0xd4, 0x39, 0x01, 0x6a, 0x40, 0xa6, 0xe9, 0x06, 0x01,
+	0x35, 0xf2, 0xa4, 0xe2, 0x70, 0x81, 0x4a, 0xae, 0x7c, 0xb2, 0x5c, 0x9c, 0x74, 0x33, 0xb6, 0xd2,
+	0xfe, 0xa2, 0x42, 0x3a, 0xbe, 0x8d, 0xee, 0x07, 0xea, 0x72, 0x73, 0x65, 0x47, 0x09, 0x08, 0x71,
+	0xf2, 0xc4, 0xa2, 0x4a, 0xba, 0x4e, 0xa0, 0xfd, 0x0d, 0x58, 0xe8, 0x12, 0x7e, 0x32, 0x35, 0x4c,
+	0x66, 0x08, 0x6f, 0x8a, 0x3d, 0x9c, 0xac, 0xdc, 0xdb, 0x64, 0x55, 0xbe, 0x83, 0x5e, 0x82, 0xc5,
+	0x18, 0xf6, 0x01, 0xb6, 0xf7, 0x0f, 0x98, 0x30, 0x58, 0x4a, 0xcf, 0x85, 0xa8, 0xef, 0x08, 0xb0,
+	0xf6, 0x43, 0x05, 0x16, 0xfa, 0x4f, 0x45, 0x1a, 0x2c, 0x97, 0xee, 0x6d, 0x57, 0x6a, 0xdb, 0x5b,
+	0x46, 0x63, 0x67, 0x73, 0xa7, 0x6a, 0x54, 0xb7, 0xef, 0xdf, 0x35, 0xee, 0x6f, 0x37, 0xea, 0xd5,
+	0x72, 0xed, 0x66, 0xad, 0x5a, 0x59, 0x38, 0x83, 0x9e, 0x85, 0xcb, 0xc7, 0xe0, 0x70, 0x50, 0xb5,
+	0xb2, 0xa0, 0xa0, 0x02, 0x5c, 0x39, 0x96, 0x85, 0x04, 0x2e, 0xa8, 0xe8, 0x2a, 0x3c, 0x73, 0x22,
+	0x46, 0xb5, 0xb2, 0x30, 0xa5, 0xfd, 0x4b, 0x85, 0x6c, 0xd2, 0x19, 0xd0, 0x37, 0x92, 0xe6, 0x2d,
+	0x8f, 0xeb, 0x4d, 0x7d, 0xcb, 0x98, 0x89, 0xb5, 0x8f, 0x54, 0x40, 0x83, 0xbb, 0xe8, 0x3a, 0x14,
+	0x76, 0x37, 0xef, 0xd4, 0x2a, 0x9b, 0x3b, 0xf7, 0xf4, 0x93, 0x8d, 0x51, 0x80, 0x2b, 0xc7, 0x62,
+	0x55, 0xaa, 0x37, 0x6b, 0xdb, 0xc2, 0x1e, 0xcf, 0xc1, 0xb3, 0xc7, 0x62, 0xd4, 0xb6, 0x37, 0xcb,
+	0x3b, 0xb5, 0xdd, 0xaa, 0x6f, 0x90, 0x63, 0x51, 0x24, 0xc2, 0xd4, 0x89, 0x08, 0xb7, 0x36, 0x6b,
+	0x77, 0xaa, 0x95, 0x85, 0x14, 0xba, 0x06, 0x57, 0x8f, 0x45, 0xd8, 0xb9, 0x77, 0xb7, 0xd4, 0xd8,
+	0xb9, 0xc7, 0x25, 0x99, 0x3e, 0x51, 0x92, 0x4a, 0xad, 0xb1, 0x59, 0xe2, 0x7c, 0x66, 0xb4, 0x7f,
+	0x2a, 0xb1, 0x6c, 0x5d, 0x23, 0x7b, 0x2e, 0xaa, 0xc1, 0x5c, 0x18, 0x00, 0x65, 0x28, 0x78, 0x79,
+	0x0c, 0xe3, 0xeb, 0x11, 0x35, 0xaa, 0xc1, 0x0c, 0x15, 0x21, 0x46, 0x86, 0x84, 0xb5, 0x31, 0x2f,
+	0xb1, 0x4b, 0x75, 0xc9, 0x00, 0x6d, 0xc1, 0x9c, 0x48, 0x63, 0x96, 0xc9, 0x4c, 0x19, 0x11, 0x5e,
+	0x1a, 0xce, 0x2d, 0x88, 0xd5, 0xba, 0xc8, 0x81, 0xfc, 0x4b, 0xfb, 0x0e, 0x9c, 0x0b, 0xcf, 0xa8,
+	0xe0, 0x3d, 0x9b, 0xd8, 0xa2, 0x3c, 0x9b, 0xa0, 0xd6, 0x97, 0x61, 0xd6, 0xec, 0xb2, 0x03, 0x83,
+	0xda, 0xfb, 0xb2, 0xb2, 0x3c, 0xcb, 0xd7, 0x0d, 0x7b, 0x5f, 0xfb, 0x58, 0x85, 0xd9, 0x8a, 0xac,
+	0x7d, 0xd1, 0xbb, 0x80, 0xa2, 0x34, 0x15, 0x04, 0xd2, 0x31, 0x82, 0xef, 0x62, 0x48, 0x1d, 0x40,
+	0xfb, 0x53, 0x92, 0x3a, 0x90, 0x92, 0xaa, 0x20, 0xc3, 0x02, 0xb6, 0x0c, 0x53, 0x84, 0xce, 0x91,
+	0xc2, 0x6b, 0x36, 0x20, 0xf2, 0xd7, 0xa8, 0x06, 0x8b, 0xb2, 0x84, 0xb7, 0x5d, 0x12, 0x30, 0x1a,
+	0x25, 0x5f, 0x2f, 0x44, 0x64, 0x3e, 0x44, 0xfb, 0xbb, 0x0a, 0x10, 0x35, 0x04, 0xff, 0x09, 0xa3,
+	0x14, 0x61, 0x91, 0x32, 0xd3, 0x93, 0xc1, 0x74, 0xa0, 0x16, 0xc9, 0x89, 0xcd, 0xea, 0x53, 0x6c,
+	0x23, 0x54, 0x01, 0xd8, 0xf3, 0x5c, 0x47, 0x66, 0x03, 0xbf, 0x86, 0x79, 0xfe, 0x64, 0xef, 0x6c,
+	0x31, 0xce, 0x4d, 0x68, 0xa4, 0xcf, 0x71, 0x42, 0xf1, 0xa9, 0x79, 0x90, 0xeb, 0xeb, 0xbc, 0x50,
+	0x0d, 0x52, 0x4d, 0xd7, 0x0a, 0xec, 0xfb, 0xe5, 0xe1, 0x0e, 0xdf, 0xc7, 0xa0, 0xe4, 0x5a, 0x47,
+	0xba, 0x60, 0xc1, 0xfb, 0xb7, 0x0e, 0x6f, 0xe4, 0xa4, 0xcb, 0xfb, 0x0b, 0xed, 0x73, 0x15, 0xce,
+	0x1d, 0x43, 0xf3, 0x34, 0x5c, 0x73, 0x19, 0xce, 0x76, 0x30, 0x31, 0xdb, 0xec, 0x48, 0x5e, 0xef,
+	0x8b, 0xc3, 0xd5, 0xaf, 0xfb, 0x04, 0x7a, 0x40, 0x89, 0xde, 0xe3, 0xa5, 0x59, 0x5b, 0x74, 0x4d,
+	0xbc, 0x4d, 0xb0, 0x99, 0x83, 0xc3, 0x5b, 0xee, 0xe7, 0xe7, 0xf7, 0xdc, 0xbc, 0x0e, 0xf0, 0x29,
+	0xca, 0x21, 0x81, 0xbe, 0xd8, 0xec, 0x07, 0xa1, 0x57, 0xe1, 0xa2, 0xef, 0x50, 0xb2, 0x8c, 0xf1,
+	0xc2, 0xf4, 0x3e, 0x2d, 0x5e, 0xf5, 0xf9, 0x70, 0xb7, 0xc1, 0x37, 0x65, 0x8e, 0xff, 0xeb, 0xd4,
+	0x80, 0xbd, 0xeb, 0x6d, 0x93, 0x3c, 0x65, 0xf6, 0x4e, 0x9d, 0xda, 0xde, 0x5b, 0x41, 0x75, 0xc4,
+	0xad, 0x22, 0xdf, 0xd4, 0x28, 0x35, 0x7d, 0x2e, 0xa4, 0x92, 0x4f, 0xea, 0x45, 0x5e, 0x9b, 0xfb,
+	0x17, 0xd7, 0x6c, 0xdb, 0x62, 0x27, 0x3f, 0x23, 0x3c, 0x37, 0x27, 0xe1, 0x25, 0x09, 0x46, 0x2b,
+	0xb0, 0x20, 0x9c, 0x39, 0x44, 0x34, 0xfc, 0x36, 0x3a, 0xad, 0x67, 0x05, 0x3c, 0x40, 0xd4, 0x8f,
+	0xc1, 0xa4, 0xa2, 0xd9, 0xef, 0xc7, 0x6c, 0x3c, 0xe1, 0x76, 0xe7, 0x9e, 0x70, 0xbb, 0xbf, 0x54,
+	0x60, 0xb1, 0x12, 0x06, 0x87, 0xb2, 0xa8, 0xea, 0x29, 0xba, 0x03, 0xf3, 0x51, 0xc4, 0x08, 0x7a,
+	0xeb, 0x11, 0x92, 0x63, 0x90, 0x88, 0xf4, 0x38, 0x39, 0xd2, 0x21, 0xd3, 0x25, 0x71, 0x7e, 0xaa,
+	0xe0, 0x77, 0x63, 0x9c, 0xd8, 0xa0, 0x27, 0x59, 0x68, 0x6d, 0x98, 0xb9, 0xdf, 0x61, 0xb6, 0x83,
+	0xd1, 0xcb, 0x80, 0x4c, 0x6a, 0x08, 0x0b, 0xb9, 0xad, 0x47, 0x81, 0xce, 0x7e, 0xeb, 0x94, 0x33,
+	0xe9, 0xbd, 0xbd, 0x12, 0x87, 0xfb, 0xea, 0xa2, 0x67, 0x01, 0x0e, 0x6d, 0x62, 0xb9, 0x87, 0x46,
+	0x1b, 0x13, 0xd9, 0xbc, 0xce, 0xf9, 0x90, 0x3b, 0x98, 0xa0, 0x8b, 0x30, 0xd3, 0xb4, 0x59, 0x0f,
+	0xb7, 0xc4, 0xfb, 0x4d, 0xeb, 0x72, 0xa5, 0x35, 0xe1, 0x7c, 0xb9, 0xeb, 0x79, 0x98, 0xb0, 0x72,
+	0x6c, 0xa0, 0x43, 0xd1, 0x2d, 0xc8, 0x26, 0xc6, 0x3e, 0x81, 0xa9, 0xae, 0x9d, 0xe0, 0xff, 0x71,
+	0x6a, 0x3d, 0x13, 0x1f, 0x0e, 0x51, 0xed, 0x2a, 0x9c, 0x95, 0xbe, 0x79, 0xc2, 0xe0, 0xea, 0xdb,
+	0x70, 0x69, 0x0b, 0xb3, 0x44, 0x65, 0xa5, 0xe3, 0xf7, 0xbb, 0x98, 0xb2, 0x81, 0x76, 0x4b, 0x3d,
+	0x55, 0xbb, 0xa5, 0x79, 0x90, 0x1f, 0x3c, 0x81, 0x76, 0xb8, 0x98, 0x68, 0x37, 0x3e, 0x71, 0xb1,
+	0xc9, 0x9e, 0x2b, 0x9f, 0xfa, 0xea, 0x18, 0x25, 0x8d, 0x60, 0x18, 0x8d, 0x5f, 0xf8, 0x52, 0x7b,
+	0x03, 0xce, 0x1f, 0xab, 0xd2, 0x35, 0xc8, 0xd0, 0x03, 0xf7, 0xd0, 0xb0, 0x89, 0xd9, 0x62, 0x76,
+	0xcf, 0x6f, 0x01, 0x67, 0xf5, 0x34, 0x07, 0xd6, 0x24, 0x4c, 0x73, 0xe1, 0xc2, 0x7f, 0x57, 0x5a,
+	0x03, 0x2e, 0xf6, 0x97, 0x93, 0x93, 0xbd, 0x02, 0x0b, 0x2e, 0x0d, 0x1c, 0x20, 0x75, 0x8a, 0x4a,
+	0x5f, 0xe5, 0x0b, 0x96, 0xbe, 0xda, 0x2f, 0x94, 0xd8, 0x31, 0x41, 0x44, 0x9c, 0xa8, 0x22, 0xbc,
+	0x8d, 0x1c, 0x8c, 0xe5, 0xb2, 0x8d, 0xec, 0x8f, 0xe3, 0xff, 0x07, 0x39, 0x4c, 0xac, 0x04, 0x66,
+	0x4a, 0x60, 0x66, 0x30, 0xb1, 0x22, 0x3c, 0xcd, 0x80, 0xfc, 0xa0, 0xd4, 0xd2, 0x3a, 0xb1, 0x5c,
+	0xa0, 0x9c, 0x36, 0x17, 0x68, 0x16, 0x3c, 0x23, 0xdf, 0x79, 0x54, 0x86, 0xf3, 0xe0, 0x33, 0xd9,
+	0x3b, 0xfe, 0x16, 0x5c, 0x39, 0xfe, 0x14, 0xa9, 0xca, 0x9b, 0x90, 0x12, 0x3d, 0x89, 0x32, 0x76,
+	0x4f, 0x22, 0xe8, 0x12, 0x4e, 0xea, 0x07, 0xc9, 0x09, 0x2b, 0xf0, 0xcd, 0x98, 0xf7, 0x04, 0x07,
+	0x48, 0xd9, 0xdf, 0x86, 0x99, 0xae, 0x80, 0x48, 0xe9, 0x57, 0x46, 0x08, 0xf2, 0x3e, 0x07, 0x49,
+	0xa7, 0x7d, 0x98, 0x82, 0x5c, 0x83, 0xef, 0xd5, 0x4d, 0xcf, 0x74, 0x30, 0xc3, 0x1e, 0x45, 0xff,
+	0x1f, 0xcf, 0xd1, 0xc2, 0x4d, 0xfc, 0x47, 0x20, 0xeb, 0x82, 0x70, 0x4f, 0xf8, 0x0a, 0xe5, 0xa9,
+	0xd0, 0x0f, 0x10, 0x46, 0x14, 0x04, 0xda, 0xb6, 0x63, 0x33, 0xd9, 0xbe, 0x9c, 0xf7, 0x77, 0x63,
+	0x23, 0x65, 0xc7, 0x66, 0x3c, 0xd5, 0x0e, 0xcc, 0xd6, 0x7c, 0x87, 0xed, 0x9f, 0x9e, 0xbd, 0x0d,
+	0x57, 0x68, 0xdb, 0xa4, 0x07, 0x62, 0xa0, 0xe4, 0xbb, 0x8e, 0xe1, 0xd8, 0xb4, 0x89, 0x0f, 0xcc,
+	0x9e, 0xed, 0x7a, 0xd2, 0x79, 0x97, 0x02, 0x1c, 0xe9, 0x66, 0x77, 0x23, 0x0c, 0xb4, 0x01, 0x97,
+	0x07, 0x38, 0x58, 0xee, 0x21, 0x11, 0x96, 0xf3, 0xab, 0xb1, 0x4b, 0x7d, 0xe4, 0x15, 0xb9, 0x8d,
+	0x5e, 0x83, 0x3c, 0xb5, 0xf7, 0x09, 0xb6, 0xfc, 0x8c, 0x47, 0x8d, 0x58, 0x46, 0x9b, 0x11, 0xa4,
+	0x17, 0xfc, 0x7d, 0x91, 0xf8, 0xe8, 0xd7, 0xc3, 0xec, 0xb6, 0x0e, 0x17, 0x1c, 0x9b, 0xd2, 0x88,
+	0xd0, 0x31, 0x3f, 0xb0, 0x9d, 0xae, 0x23, 0x4a, 0x8f, 0x94, 0x7e, 0xce, 0xdf, 0xf4, 0xa9, 0xee,
+	0xfa, 0x5b, 0xe8, 0x0e, 0x9c, 0x73, 0x6c, 0x12, 0xb3, 0xa3, 0xb8, 0x36, 0x51, 0x82, 0x0c, 0x2b,
+	0x90, 0x16, 0x1d, 0x9b, 0xc4, 0x03, 0xd0, 0x23, 0x8c, 0x5e, 0x80, 0xe8, 0xae, 0x0c, 0x0b, 0xb7,
+	0xcd, 0x23, 0x59, 0x9c, 0x64, 0x43, 0x70, 0x85, 0x43, 0xb5, 0x9f, 0x2b, 0x90, 0xdd, 0xc2, 0x04,
+	0x53, 0x9b, 0x96, 0x5d, 0xc2, 0x78, 0xf5, 0xba, 0x03, 0x69, 0x71, 0xb6, 0xd1, 0xe1, 0x7e, 0x31,
+	0x46, 0x10, 0xec, 0x73, 0x26, 0x7d, 0x9e, 0x86, 0x00, 0x8a, 0x6e, 0x03, 0x84, 0xba, 0x05, 0x85,
+	0xc9, 0x58, 0x5d, 0x7a, 0x8c, 0x5c, 0xfb, 0x5c, 0x81, 0x4b, 0xd5, 0x1e, 0x26, 0x6c, 0xc7, 0x75,
+	0x9a, 0x94, 0xb9, 0x24, 0x72, 0x31, 0xae, 0x3a, 0xee, 0xf1, 0x47, 0xd4, 0xc2, 0xc9, 0x1a, 0x25,
+	0x1b, 0x80, 0x65, 0x89, 0xf2, 0x3c, 0x64, 0x5b, 0x7e, 0x74, 0x08, 0xf0, 0x7c, 0xa7, 0xcd, 0x48,
+	0xa8, 0x44, 0xeb, 0x7f, 0xca, 0xa9, 0xd3, 0x85, 0xe9, 0xd8, 0x6f, 0x02, 0xd3, 0x72, 0xb0, 0x20,
+	0x7f, 0x13, 0x78, 0xae, 0x6f, 0x66, 0xea, 0xbb, 0x56, 0x7c, 0x2a, 0xaa, 0x7d, 0xa2, 0xc0, 0x65,
+	0xa1, 0x6f, 0x72, 0xf4, 0xe5, 0x57, 0x91, 0x4f, 0xd9, 0x0c, 0x58, 0xfb, 0xa9, 0x02, 0x57, 0x93,
+	0xc2, 0xee, 0x46, 0xaa, 0x4c, 0x56, 0xe4, 0xfe, 0x71, 0xb3, 0x3a, 0xe6, 0xb8, 0x59, 0xfb, 0xb5,
+	0x02, 0x85, 0xa4, 0xac, 0xf1, 0x29, 0xeb, 0x64, 0x85, 0x1d, 0x18, 0x6d, 0xab, 0x13, 0x18, 0x6d,
+	0xff, 0x44, 0x81, 0x73, 0x42, 0x81, 0x20, 0x35, 0x4d, 0x56, 0xe6, 0xc4, 0xe8, 0x4e, 0xfd, 0x02,
+	0xa3, 0xbb, 0x47, 0xb0, 0x9c, 0xb4, 0x73, 0x34, 0xbf, 0xbb, 0xdf, 0x69, 0xbb, 0xa6, 0x35, 0xc1,
+	0x29, 0x9e, 0xd6, 0xec, 0x7f, 0x2d, 0x77, 0xa3, 0x80, 0x3b, 0x21, 0xcb, 0x68, 0xdf, 0x53, 0x20,
+	0x23, 0x0e, 0x09, 0x67, 0x82, 0x13, 0x32, 0xf9, 0xab, 0x30, 0x33, 0xc6, 0xe4, 0x4a, 0xe2, 0x6a,
+	0xdf, 0x57, 0x20, 0x27, 0xc4, 0x89, 0xcd, 0xe3, 0xfe, 0xa7, 0x02, 0xfd, 0x41, 0x81, 0x67, 0x84,
+	0x40, 0x8d, 0x64, 0x76, 0xdd, 0xec, 0x74, 0xda, 0x36, 0xb6, 0x26, 0x25, 0xdc, 0xd0, 0xa9, 0xe9,
+	0x2d, 0x98, 0x27, 0xf8, 0xd0, 0x38, 0xf5, 0xb8, 0x08, 0x08, 0x3e, 0x94, 0xdf, 0xeb, 0x7f, 0x9c,
+	0x81, 0xf4, 0xbb, 0x5d, 0xec, 0x1d, 0x35, 0xb0, 0xd7, 0xb3, 0x5b, 0x18, 0x7d, 0xa4, 0xc0, 0x42,
+	0x7f, 0x23, 0x87, 0x46, 0xf8, 0x05, 0xfb, 0x84, 0xf6, 0x72, 0x69, 0xe3, 0x34, 0xa4, 0xb2, 0x20,
+	0xfc, 0x70, 0xe0, 0xd7, 0x80, 0xaf, 0x8c, 0xdb, 0x83, 0x49, 0x29, 0x5e, 0x1b, 0x9b, 0xce, 0x17,
+	0xe1, 0x15, 0x05, 0x7d, 0x57, 0x19, 0xfc, 0x89, 0xf2, 0xab, 0xe3, 0xb7, 0x4f, 0x52, 0x90, 0xd7,
+	0x4f, 0x41, 0x29, 0xad, 0xc1, 0x6f, 0xa6, 0xbf, 0x85, 0x41, 0xe3, 0xf0, 0x4b, 0x36, 0x6b, 0xa3,
+	0xdc, 0xcc, 0x89, 0x1d, 0xd3, 0x0f, 0x94, 0x70, 0xaa, 0x91, 0xe8, 0x43, 0xd0, 0xd7, 0x86, 0x33,
+	0x7d, 0x42, 0x97, 0xb4, 0xf4, 0xe6, 0x69, 0xc9, 0xa5, 0x5c, 0x89, 0xcb, 0x92, 0x43, 0x9e, 0x71,
+	0x2e, 0x2b, 0xd1, 0xf2, 0x8c, 0x75, 0x59, 0xc9, 0x5e, 0xa6, 0xf4, 0x5b, 0xf5, 0x77, 0x8f, 0x97,
+	0x95, 0x4f, 0x1f, 0x2f, 0x2b, 0x7f, 0x7b, 0xbc, 0xac, 0x7c, 0xfc, 0xd9, 0xf2, 0x99, 0x4f, 0x3f,
+	0x5b, 0x3e, 0xf3, 0xe7, 0xcf, 0x96, 0xcf, 0xc0, 0xf5, 0x96, 0xeb, 0x0c, 0x65, 0x5c, 0x02, 0xbf,
+	0xf4, 0xf4, 0x5c, 0xe6, 0xd6, 0x95, 0x07, 0x3b, 0xfb, 0x36, 0x3b, 0xe8, 0x36, 0x39, 0xe2, 0x6a,
+	0xcb, 0xa5, 0x8e, 0x4b, 0x57, 0x3d, 0x5e, 0xec, 0x62, 0x6f, 0xb5, 0xb7, 0x1e, 0x7e, 0xb6, 0x0e,
+	0x4c, 0x9b, 0xd0, 0xd5, 0x61, 0x7f, 0xb4, 0xf5, 0x86, 0xf8, 0xe8, 0xad, 0xfd, 0x58, 0x4d, 0xd5,
+	0xcb, 0xe5, 0xc6, 0x27, 0x6a, 0xa1, 0x1e, 0x48, 0x53, 0xe6, 0xd2, 0x94, 0x43, 0x69, 0x84, 0x0c,
+	0xc5, 0xdd, 0xb5, 0xdf, 0x47, 0x28, 0x0f, 0x39, 0xca, 0xc3, 0x10, 0xe5, 0xa1, 0x40, 0x79, 0xb8,
+	0xbb, 0xf6, 0x58, 0xbd, 0x31, 0x0c, 0xe5, 0xe1, 0x56, 0xbd, 0x74, 0x17, 0x33, 0x93, 0x67, 0xde,
+	0x7f, 0xa8, 0xd7, 0x03, 0xf4, 0x8d, 0x0d, 0x8e, 0xcf, 0xff, 0x95, 0x04, 0x1b, 0x1b, 0x82, 0x62,
+	0x63, 0x63, 0x77, 0xad, 0x39, 0x23, 0xfe, 0x50, 0xeb, 0x4b, 0xff, 0x0e, 0x00, 0x00, 0xff, 0xff,
+	0x1c, 0x16, 0x3a, 0x30, 0x8a, 0x26, 0x00, 0x00,
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// QueryServiceClient is the client API for QueryService service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
+type QueryServiceClient interface {
+	// Queries for information about a specific validator.
+	GetValidatorInfo(ctx context.Context, in *GetValidatorInfoRequest, opts ...grpc.CallOption) (*GetValidatorInfoResponse, error)
+	// Queries the current validator set, with filtering.
+	ValidatorInfo(ctx context.Context, in *ValidatorInfoRequest, opts ...grpc.CallOption) (QueryService_ValidatorInfoClient, error)
+	ValidatorStatus(ctx context.Context, in *ValidatorStatusRequest, opts ...grpc.CallOption) (*ValidatorStatusResponse, error)
+	ValidatorPenalty(ctx context.Context, in *ValidatorPenaltyRequest, opts ...grpc.CallOption) (*ValidatorPenaltyResponse, error)
+	CurrentValidatorRate(ctx context.Context, in *CurrentValidatorRateRequest, opts ...grpc.CallOption) (*CurrentValidatorRateResponse, error)
+	ValidatorUptime(ctx context.Context, in *ValidatorUptimeRequest, opts ...grpc.CallOption) (*ValidatorUptimeResponse, error)
+}
+
+type queryServiceClient struct {
+	cc grpc1.ClientConn
+}
+
+func NewQueryServiceClient(cc grpc1.ClientConn) QueryServiceClient {
+	return &queryServiceClient{cc}
+}
+
+func (c *queryServiceClient) GetValidatorInfo(ctx context.Context, in *GetValidatorInfoRequest, opts ...grpc.CallOption) (*GetValidatorInfoResponse, error) {
+	out := new(GetValidatorInfoResponse)
+	err := c.cc.Invoke(ctx, "/penumbra.core.component.stake.v1.QueryService/GetValidatorInfo", in, out, opts...)
+	if err != nil {
+		return nil, err
 	}
-	return len(dAtA) - i, nil
+	return out, nil
 }
 
-func (m *ValidatorList) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+func (c *queryServiceClient) ValidatorInfo(ctx context.Context, in *ValidatorInfoRequest, opts ...grpc.CallOption) (QueryService_ValidatorInfoClient, error) {
+	stream, err := c.cc.NewStream(ctx, &_QueryService_serviceDesc.Streams[0], "/penumbra.core.component.stake.v1.QueryService/ValidatorInfo", opts...)
 	if err != nil {
 		return nil, err
 	}
-	return dAtA[:n], nil
+	x := &queryServiceValidatorInfoClient{stream}
+	if err := x.ClientStream.SendMsg(in); err != nil {
+		return nil, err
+	}
+	if err := x.ClientStream.CloseSend(); err != nil {
+		return nil, err
+	}
+	return x, nil
 }
 
-func (m *ValidatorList) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
+type QueryService_ValidatorInfoClient interface {
+	Recv() (*ValidatorInfoResponse, error)
+	grpc.ClientStream
 }
 
-func (m *ValidatorList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if len(m.ValidatorKeys) > 0 {
-		for iNdEx := len(m.ValidatorKeys) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.ValidatorKeys[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintStake(dAtA, i, uint64(size))
-			}
-			i--
-			dAtA[i] = 0xa
-		}
+type queryServiceValidatorInfoClient struct {
+	grpc.ClientStream
+}
+
+func (x *queryServiceValidatorInfoClient) Recv() (*ValidatorInfoResponse, error) {
+	m := new(ValidatorInfoResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
 	}
-	return len(dAtA) - i, nil
+	return m, nil
 }
 
-func (m *FundingStream) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+func (c *queryServiceClient) ValidatorStatus(ctx context.Context, in *ValidatorStatusRequest, opts ...grpc.CallOption) (*ValidatorStatusResponse, error) {
+	out := new(ValidatorStatusResponse)
+	err := c.cc.Invoke(ctx, "/penumbra.core.component.stake.v1.QueryService/ValidatorStatus", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
-	return dAtA[:n], nil
+	return out, nil
 }
 
-func (m *FundingStream) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
+func (c *queryServiceClient) ValidatorPenalty(ctx context.Context, in *ValidatorPenaltyRequest, opts ...grpc.CallOption) (*ValidatorPenaltyResponse, error) {
+	out := new(ValidatorPenaltyResponse)
+	err := c.cc.Invoke(ctx, "/penumbra.core.component.stake.v1.QueryService/ValidatorPenalty", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
-func (m *FundingStream) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if m.Recipient != nil {
-		{
-			size := m.Recipient.Size()
-			i -= size
-			if _, err := m.Recipient.MarshalTo(dAtA[i:]); err != nil {
-				return 0, err
-			}
-		}
+func (c *queryServiceClient) CurrentValidatorRate(ctx context.Context, in *CurrentValidatorRateRequest, opts ...grpc.CallOption) (*CurrentValidatorRateResponse, error) {
+	out := new(CurrentValidatorRateResponse)
+	err := c.cc.Invoke(ctx, "/penumbra.core.component.stake.v1.QueryService/CurrentValidatorRate", in, out, opts...)
+	if err != nil {
+		return nil, err
 	}
-	return len(dAtA) - i, nil
+	return out, nil
 }
 
-func (m *FundingStream_ToAddress_) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
+func (c *queryServiceClient) ValidatorUptime(ctx context.Context, in *ValidatorUptimeRequest, opts ...grpc.CallOption) (*ValidatorUptimeResponse, error) {
+	out := new(ValidatorUptimeResponse)
+	err := c.cc.Invoke(ctx, "/penumbra.core.component.stake.v1.QueryService/ValidatorUptime", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
 }
 
-func (m *FundingStream_ToAddress_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	if m.ToAddress != nil {
-		{
-			size, err := m.ToAddress.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintStake(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0xa
+// QueryServiceServer is the server API for QueryService service.
+type QueryServiceServer interface {
+	// Queries for information about a specific validator.
+	GetValidatorInfo(context.Context, *GetValidatorInfoRequest) (*GetValidatorInfoResponse, error)
+	// Queries the current validator set, with filtering.
+	ValidatorInfo(*ValidatorInfoRequest, QueryService_ValidatorInfoServer) error
+	ValidatorStatus(context.Context, *ValidatorStatusRequest) (*ValidatorStatusResponse, error)
+	ValidatorPenalty(context.Context, *ValidatorPenaltyRequest) (*ValidatorPenaltyResponse, error)
+	CurrentValidatorRate(context.Context, *CurrentValidatorRateRequest) (*CurrentValidatorRateResponse, error)
+	ValidatorUptime(context.Context, *ValidatorUptimeRequest) (*ValidatorUptimeResponse, error)
+}
+
+// UnimplementedQueryServiceServer can be embedded to have forward compatible implementations.
+type UnimplementedQueryServiceServer struct {
+}
+
+func (*UnimplementedQueryServiceServer) GetValidatorInfo(ctx context.Context, req *GetValidatorInfoRequest) (*GetValidatorInfoResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetValidatorInfo not implemented")
+}
+func (*UnimplementedQueryServiceServer) ValidatorInfo(req *ValidatorInfoRequest, srv QueryService_ValidatorInfoServer) error {
+	return status.Errorf(codes.Unimplemented, "method ValidatorInfo not implemented")
+}
+func (*UnimplementedQueryServiceServer) ValidatorStatus(ctx context.Context, req *ValidatorStatusRequest) (*ValidatorStatusResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ValidatorStatus not implemented")
+}
+func (*UnimplementedQueryServiceServer) ValidatorPenalty(ctx context.Context, req *ValidatorPenaltyRequest) (*ValidatorPenaltyResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ValidatorPenalty not implemented")
+}
+func (*UnimplementedQueryServiceServer) CurrentValidatorRate(ctx context.Context, req *CurrentValidatorRateRequest) (*CurrentValidatorRateResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method CurrentValidatorRate not implemented")
+}
+func (*UnimplementedQueryServiceServer) ValidatorUptime(ctx context.Context, req *ValidatorUptimeRequest) (*ValidatorUptimeResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ValidatorUptime not implemented")
+}
+
+func RegisterQueryServiceServer(s grpc1.Server, srv QueryServiceServer) {
+	s.RegisterService(&_QueryService_serviceDesc, srv)
+}
+
+func _QueryService_GetValidatorInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(GetValidatorInfoRequest)
+	if err := dec(in); err != nil {
+		return nil, err
 	}
-	return len(dAtA) - i, nil
+	if interceptor == nil {
+		return srv.(QueryServiceServer).GetValidatorInfo(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/penumbra.core.component.stake.v1.QueryService/GetValidatorInfo",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServiceServer).GetValidatorInfo(ctx, req.(*GetValidatorInfoRequest))
+	}
+	return interceptor(ctx, in, info, handler)
 }
-func (m *FundingStream_ToCommunityPool_) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
+
+func _QueryService_ValidatorInfo_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(ValidatorInfoRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(QueryServiceServer).ValidatorInfo(m, &queryServiceValidatorInfoServer{stream})
 }
 
-func (m *FundingStream_ToCommunityPool_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	if m.ToCommunityPool != nil {
-		{
-			size, err := m.ToCommunityPool.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintStake(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x12
+type QueryService_ValidatorInfoServer interface {
+	Send(*ValidatorInfoResponse) error
+	grpc.ServerStream
+}
+
+type queryServiceValidatorInfoServer struct {
+	grpc.ServerStream
+}
+
+func (x *queryServiceValidatorInfoServer) Send(m *ValidatorInfoResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func _QueryService_ValidatorStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ValidatorStatusRequest)
+	if err := dec(in); err != nil {
+		return nil, err
 	}
-	return len(dAtA) - i, nil
+	if interceptor == nil {
+		return srv.(QueryServiceServer).ValidatorStatus(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/penumbra.core.component.stake.v1.QueryService/ValidatorStatus",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServiceServer).ValidatorStatus(ctx, req.(*ValidatorStatusRequest))
+	}
+	return interceptor(ctx, in, info, handler)
 }
-func (m *FundingStream_ToAddress) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
+
+func _QueryService_ValidatorPenalty_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ValidatorPenaltyRequest)
+	if err := dec(in); err != nil {
 		return nil, err
 	}
-	return dAtA[:n], nil
+	if interceptor == nil {
+		return srv.(QueryServiceServer).ValidatorPenalty(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/penumbra.core.component.stake.v1.QueryService/ValidatorPenalty",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServiceServer).ValidatorPenalty(ctx, req.(*ValidatorPenaltyRequest))
+	}
+	return interceptor(ctx, in, info, handler)
 }
 
-func (m *FundingStream_ToAddress) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
+func _QueryService_CurrentValidatorRate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(CurrentValidatorRateRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServiceServer).CurrentValidatorRate(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/penumbra.core.component.stake.v1.QueryService/CurrentValidatorRate",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServiceServer).CurrentValidatorRate(ctx, req.(*CurrentValidatorRateRequest))
+	}
+	return interceptor(ctx, in, info, handler)
 }
 
-func (m *FundingStream_ToAddress) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if m.RateBps != 0 {
-		i = encodeVarintStake(dAtA, i, uint64(m.RateBps))
-		i--
-		dAtA[i] = 0x10
+func _QueryService_ValidatorUptime_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ValidatorUptimeRequest)
+	if err := dec(in); err != nil {
+		return nil, err
 	}
-	if len(m.Address) > 0 {
-		i -= len(m.Address)
-		copy(dAtA[i:], m.Address)
-		i = encodeVarintStake(dAtA, i, uint64(len(m.Address)))
-		i--
-		dAtA[i] = 0xa
+	if interceptor == nil {
+		return srv.(QueryServiceServer).ValidatorUptime(ctx, in)
 	}
-	return len(dAtA) - i, nil
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/penumbra.core.component.stake.v1.QueryService/ValidatorUptime",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServiceServer).ValidatorUptime(ctx, req.(*ValidatorUptimeRequest))
+	}
+	return interceptor(ctx, in, info, handler)
 }
 
-func (m *FundingStream_ToCommunityPool) Marshal() (dAtA []byte, err error) {
+var _QueryService_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "penumbra.core.component.stake.v1.QueryService",
+	HandlerType: (*QueryServiceServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "GetValidatorInfo",
+			Handler:    _QueryService_GetValidatorInfo_Handler,
+		},
+		{
+			MethodName: "ValidatorStatus",
+			Handler:    _QueryService_ValidatorStatus_Handler,
+		},
+		{
+			MethodName: "ValidatorPenalty",
+			Handler:    _QueryService_ValidatorPenalty_Handler,
+		},
+		{
+			MethodName: "CurrentValidatorRate",
+			Handler:    _QueryService_CurrentValidatorRate_Handler,
+		},
+		{
+			MethodName: "ValidatorUptime",
+			Handler:    _QueryService_ValidatorUptime_Handler,
+		},
+	},
+	Streams: []grpc.StreamDesc{
+		{
+			StreamName:    "ValidatorInfo",
+			Handler:       _QueryService_ValidatorInfo_Handler,
+			ServerStreams: true,
+		},
+	},
+	Metadata: "penumbra/core/component/stake/v1/stake.proto",
+}
+
+func (m *ZKUndelegateClaimProof) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -3137,25 +3355,27 @@ func (m *FundingStream_ToCommunityPool) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *FundingStream_ToCommunityPool) MarshalTo(dAtA []byte) (int, error) {
+func (m *ZKUndelegateClaimProof) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *FundingStream_ToCommunityPool) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *ZKUndelegateClaimProof) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.RateBps != 0 {
-		i = encodeVarintStake(dAtA, i, uint64(m.RateBps))
+	if len(m.Inner) > 0 {
+		i -= len(m.Inner)
+		copy(dAtA[i:], m.Inner)
+		i = encodeVarintStake(dAtA, i, uint64(len(m.Inner)))
 		i--
-		dAtA[i] = 0x10
+		dAtA[i] = 0xa
 	}
 	return len(dAtA) - i, nil
 }
 
-func (m *RateData) Marshal() (dAtA []byte, err error) {
+func (m *Validator) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -3165,19 +3385,19 @@ func (m *RateData) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *RateData) MarshalTo(dAtA []byte) (int, error) {
+func (m *Validator) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *RateData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *Validator) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.ValidatorExchangeRate != nil {
+	if m.GovernanceKey != nil {
 		{
-			size, err := m.ValidatorExchangeRate.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.GovernanceKey.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -3185,24 +3405,64 @@ func (m *RateData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			i = encodeVarintStake(dAtA, i, uint64(size))
 		}
 		i--
-		dAtA[i] = 0x2a
+		dAtA[i] = 0x4a
 	}
-	if m.ValidatorRewardRate != nil {
-		{
-			size, err := m.ValidatorRewardRate.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
+	if m.Enabled {
+		i--
+		if m.Enabled {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i--
+		dAtA[i] = 0x40
+	}
+	if m.SequenceNumber != 0 {
+		i = encodeVarintStake(dAtA, i, uint64(m.SequenceNumber))
+		i--
+		dAtA[i] = 0x38
+	}
+	if len(m.FundingStreams) > 0 {
+		for iNdEx := len(m.FundingStreams) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.FundingStreams[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintStake(dAtA, i, uint64(size))
 			}
-			i -= size
-			i = encodeVarintStake(dAtA, i, uint64(size))
+			i--
+			dAtA[i] = 0x32
 		}
+	}
+	if len(m.Description) > 0 {
+		i -= len(m.Description)
+		copy(dAtA[i:], m.Description)
+		i = encodeVarintStake(dAtA, i, uint64(len(m.Description)))
+		i--
+		dAtA[i] = 0x2a
+	}
+	if len(m.Website) > 0 {
+		i -= len(m.Website)
+		copy(dAtA[i:], m.Website)
+		i = encodeVarintStake(dAtA, i, uint64(len(m.Website)))
 		i--
 		dAtA[i] = 0x22
 	}
-	if m.EpochIndex != 0 {
-		i = encodeVarintStake(dAtA, i, uint64(m.EpochIndex))
+	if len(m.Name) > 0 {
+		i -= len(m.Name)
+		copy(dAtA[i:], m.Name)
+		i = encodeVarintStake(dAtA, i, uint64(len(m.Name)))
 		i--
-		dAtA[i] = 0x10
+		dAtA[i] = 0x1a
+	}
+	if len(m.ConsensusKey) > 0 {
+		i -= len(m.ConsensusKey)
+		copy(dAtA[i:], m.ConsensusKey)
+		i = encodeVarintStake(dAtA, i, uint64(len(m.ConsensusKey)))
+		i--
+		dAtA[i] = 0x12
 	}
 	if m.IdentityKey != nil {
 		{
@@ -3219,7 +3479,7 @@ func (m *RateData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *BaseRateData) Marshal() (dAtA []byte, err error) {
+func (m *ValidatorList) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -3229,49 +3489,34 @@ func (m *BaseRateData) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *BaseRateData) MarshalTo(dAtA []byte) (int, error) {
+func (m *ValidatorList) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *BaseRateData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *ValidatorList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.BaseExchangeRate != nil {
-		{
-			size, err := m.BaseExchangeRate.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintStake(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x1a
-	}
-	if m.BaseRewardRate != nil {
-		{
-			size, err := m.BaseRewardRate.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
+	if len(m.ValidatorKeys) > 0 {
+		for iNdEx := len(m.ValidatorKeys) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.ValidatorKeys[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintStake(dAtA, i, uint64(size))
 			}
-			i -= size
-			i = encodeVarintStake(dAtA, i, uint64(size))
+			i--
+			dAtA[i] = 0xa
 		}
-		i--
-		dAtA[i] = 0x12
-	}
-	if m.EpochIndex != 0 {
-		i = encodeVarintStake(dAtA, i, uint64(m.EpochIndex))
-		i--
-		dAtA[i] = 0x8
 	}
 	return len(dAtA) - i, nil
 }
 
-func (m *ValidatorStatus) Marshal() (dAtA []byte, err error) {
+func (m *FundingStream) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -3281,43 +3526,38 @@ func (m *ValidatorStatus) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *ValidatorStatus) MarshalTo(dAtA []byte) (int, error) {
+func (m *FundingStream) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *ValidatorStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *FundingStream) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.BondingState != nil {
+	if m.Recipient != nil {
 		{
-			size, err := m.BondingState.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
+			size := m.Recipient.Size()
 			i -= size
-			i = encodeVarintStake(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x22
-	}
-	if m.VotingPower != nil {
-		{
-			size, err := m.VotingPower.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
+			if _, err := m.Recipient.MarshalTo(dAtA[i:]); err != nil {
 				return 0, err
 			}
-			i -= size
-			i = encodeVarintStake(dAtA, i, uint64(size))
 		}
-		i--
-		dAtA[i] = 0x1a
 	}
-	if m.State != nil {
+	return len(dAtA) - i, nil
+}
+
+func (m *FundingStream_ToAddress_) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *FundingStream_ToAddress_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	if m.ToAddress != nil {
 		{
-			size, err := m.State.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.ToAddress.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -3325,11 +3565,20 @@ func (m *ValidatorStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			i = encodeVarintStake(dAtA, i, uint64(size))
 		}
 		i--
-		dAtA[i] = 0x12
+		dAtA[i] = 0xa
 	}
-	if m.IdentityKey != nil {
+	return len(dAtA) - i, nil
+}
+func (m *FundingStream_ToCommunityPool_) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *FundingStream_ToCommunityPool_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	if m.ToCommunityPool != nil {
 		{
-			size, err := m.IdentityKey.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.ToCommunityPool.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -3337,12 +3586,11 @@ func (m *ValidatorStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			i = encodeVarintStake(dAtA, i, uint64(size))
 		}
 		i--
-		dAtA[i] = 0xa
+		dAtA[i] = 0x12
 	}
 	return len(dAtA) - i, nil
 }
-
-func (m *BondingState) Marshal() (dAtA []byte, err error) {
+func (m *FundingStream_ToAddress) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -3352,35 +3600,32 @@ func (m *BondingState) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *BondingState) MarshalTo(dAtA []byte) (int, error) {
+func (m *FundingStream_ToAddress) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *BondingState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *FundingStream_ToAddress) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.UnbondsAtHeight != 0 {
-		i = encodeVarintStake(dAtA, i, uint64(m.UnbondsAtHeight))
-		i--
-		dAtA[i] = 0x18
-	}
-	if m.UnbondsAtEpoch != 0 {
-		i = encodeVarintStake(dAtA, i, uint64(m.UnbondsAtEpoch))
+	if m.RateBps != 0 {
+		i = encodeVarintStake(dAtA, i, uint64(m.RateBps))
 		i--
 		dAtA[i] = 0x10
 	}
-	if m.State != 0 {
-		i = encodeVarintStake(dAtA, i, uint64(m.State))
+	if len(m.Address) > 0 {
+		i -= len(m.Address)
+		copy(dAtA[i:], m.Address)
+		i = encodeVarintStake(dAtA, i, uint64(len(m.Address)))
 		i--
-		dAtA[i] = 0x8
+		dAtA[i] = 0xa
 	}
 	return len(dAtA) - i, nil
 }
 
-func (m *ValidatorState) Marshal() (dAtA []byte, err error) {
+func (m *FundingStream_ToCommunityPool) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -3390,25 +3635,25 @@ func (m *ValidatorState) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *ValidatorState) MarshalTo(dAtA []byte) (int, error) {
+func (m *FundingStream_ToCommunityPool) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *ValidatorState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *FundingStream_ToCommunityPool) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.State != 0 {
-		i = encodeVarintStake(dAtA, i, uint64(m.State))
+	if m.RateBps != 0 {
+		i = encodeVarintStake(dAtA, i, uint64(m.RateBps))
 		i--
-		dAtA[i] = 0x8
+		dAtA[i] = 0x10
 	}
 	return len(dAtA) - i, nil
 }
 
-func (m *ValidatorInfo) Marshal() (dAtA []byte, err error) {
+func (m *RateData) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -3418,19 +3663,19 @@ func (m *ValidatorInfo) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *ValidatorInfo) MarshalTo(dAtA []byte) (int, error) {
+func (m *RateData) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *ValidatorInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *RateData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if m.RateData != nil {
+	if m.ValidatorExchangeRate != nil {
 		{
-			size, err := m.RateData.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.ValidatorExchangeRate.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -3438,11 +3683,11 @@ func (m *ValidatorInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			i = encodeVarintStake(dAtA, i, uint64(size))
 		}
 		i--
-		dAtA[i] = 0x1a
+		dAtA[i] = 0x2a
 	}
-	if m.Status != nil {
+	if m.ValidatorRewardRate != nil {
 		{
-			size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.ValidatorRewardRate.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -3450,11 +3695,16 @@ func (m *ValidatorInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			i = encodeVarintStake(dAtA, i, uint64(size))
 		}
 		i--
-		dAtA[i] = 0x12
+		dAtA[i] = 0x22
 	}
-	if m.Validator != nil {
+	if m.EpochIndex != 0 {
+		i = encodeVarintStake(dAtA, i, uint64(m.EpochIndex))
+		i--
+		dAtA[i] = 0x10
+	}
+	if m.IdentityKey != nil {
 		{
-			size, err := m.Validator.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.IdentityKey.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -3467,7 +3717,7 @@ func (m *ValidatorInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *ValidatorDefinition) Marshal() (dAtA []byte, err error) {
+func (m *BaseRateData) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -3477,26 +3727,31 @@ func (m *ValidatorDefinition) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *ValidatorDefinition) MarshalTo(dAtA []byte) (int, error) {
+func (m *BaseRateData) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *ValidatorDefinition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *BaseRateData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
-	if len(m.AuthSig) > 0 {
-		i -= len(m.AuthSig)
-		copy(dAtA[i:], m.AuthSig)
-		i = encodeVarintStake(dAtA, i, uint64(len(m.AuthSig)))
+	if m.BaseExchangeRate != nil {
+		{
+			size, err := m.BaseExchangeRate.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintStake(dAtA, i, uint64(size))
+		}
 		i--
-		dAtA[i] = 0x12
+		dAtA[i] = 0x1a
 	}
-	if m.Validator != nil {
+	if m.BaseRewardRate != nil {
 		{
-			size, err := m.Validator.MarshalToSizedBuffer(dAtA[:i])
+			size, err := m.BaseRewardRate.MarshalToSizedBuffer(dAtA[:i])
 			if err != nil {
 				return 0, err
 			}
@@ -3504,9 +3759,252 @@ func (m *ValidatorDefinition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			i = encodeVarintStake(dAtA, i, uint64(size))
 		}
 		i--
-		dAtA[i] = 0xa
+		dAtA[i] = 0x12
 	}
-	return len(dAtA) - i, nil
+	if m.EpochIndex != 0 {
+		i = encodeVarintStake(dAtA, i, uint64(m.EpochIndex))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *ValidatorStatus) 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 *ValidatorStatus) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ValidatorStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.BondingState != nil {
+		{
+			size, err := m.BondingState.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintStake(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x22
+	}
+	if m.VotingPower != nil {
+		{
+			size, err := m.VotingPower.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintStake(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x1a
+	}
+	if m.State != nil {
+		{
+			size, err := m.State.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintStake(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x12
+	}
+	if m.IdentityKey != nil {
+		{
+			size, err := m.IdentityKey.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintStake(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *BondingState) 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 *BondingState) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *BondingState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.UnbondsAtHeight != 0 {
+		i = encodeVarintStake(dAtA, i, uint64(m.UnbondsAtHeight))
+		i--
+		dAtA[i] = 0x18
+	}
+	if m.UnbondsAtEpoch != 0 {
+		i = encodeVarintStake(dAtA, i, uint64(m.UnbondsAtEpoch))
+		i--
+		dAtA[i] = 0x10
+	}
+	if m.State != 0 {
+		i = encodeVarintStake(dAtA, i, uint64(m.State))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *ValidatorState) 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 *ValidatorState) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ValidatorState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.State != 0 {
+		i = encodeVarintStake(dAtA, i, uint64(m.State))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *ValidatorInfo) 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 *ValidatorInfo) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ValidatorInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.RateData != nil {
+		{
+			size, err := m.RateData.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintStake(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x1a
+	}
+	if m.Status != nil {
+		{
+			size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintStake(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x12
+	}
+	if m.Validator != nil {
+		{
+			size, err := m.Validator.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintStake(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *ValidatorDefinition) 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 *ValidatorDefinition) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ValidatorDefinition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.AuthSig) > 0 {
+		i -= len(m.AuthSig)
+		copy(dAtA[i:], m.AuthSig)
+		i = encodeVarintStake(dAtA, i, uint64(len(m.AuthSig)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if m.Validator != nil {
+		{
+			size, err := m.Validator.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintStake(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
 }
 
 func (m *Delegate) Marshal() (dAtA []byte, err error) {
@@ -4617,495 +5115,559 @@ func (m *EventTombstoneValidator) MarshalToSizedBuffer(dAtA []byte) (int, error)
 	return len(dAtA) - i, nil
 }
 
-func encodeVarintStake(dAtA []byte, offset int, v uint64) int {
-	offset -= sovStake(v)
-	base := offset
-	for v >= 1<<7 {
-		dAtA[offset] = uint8(v&0x7f | 0x80)
-		v >>= 7
-		offset++
+func (m *EventValidatorStateChange) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
 	}
-	dAtA[offset] = uint8(v)
-	return base
+	return dAtA[:n], nil
 }
-func (m *ZKUndelegateClaimProof) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.Inner)
-	if l > 0 {
-		n += 1 + l + sovStake(uint64(l))
-	}
-	return n
+
+func (m *EventValidatorStateChange) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *Validator) Size() (n int) {
-	if m == nil {
-		return 0
-	}
+func (m *EventValidatorStateChange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
 	var l int
 	_ = l
-	if m.IdentityKey != nil {
-		l = m.IdentityKey.Size()
-		n += 1 + l + sovStake(uint64(l))
-	}
-	l = len(m.ConsensusKey)
-	if l > 0 {
-		n += 1 + l + sovStake(uint64(l))
-	}
-	l = len(m.Name)
-	if l > 0 {
-		n += 1 + l + sovStake(uint64(l))
-	}
-	l = len(m.Website)
-	if l > 0 {
-		n += 1 + l + sovStake(uint64(l))
-	}
-	l = len(m.Description)
-	if l > 0 {
-		n += 1 + l + sovStake(uint64(l))
-	}
-	if len(m.FundingStreams) > 0 {
-		for _, e := range m.FundingStreams {
-			l = e.Size()
-			n += 1 + l + sovStake(uint64(l))
+	if m.State != nil {
+		{
+			size, err := m.State.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintStake(dAtA, i, uint64(size))
 		}
+		i--
+		dAtA[i] = 0x12
 	}
-	if m.SequenceNumber != 0 {
-		n += 1 + sovStake(uint64(m.SequenceNumber))
-	}
-	if m.Enabled {
-		n += 2
-	}
-	if m.GovernanceKey != nil {
-		l = m.GovernanceKey.Size()
-		n += 1 + l + sovStake(uint64(l))
+	if m.IdentityKey != nil {
+		{
+			size, err := m.IdentityKey.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintStake(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
 	}
-	return n
+	return len(dAtA) - i, nil
 }
 
-func (m *ValidatorList) Size() (n int) {
-	if m == nil {
-		return 0
+func (m *EventValidatorVotingPowerChange) 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 *EventValidatorVotingPowerChange) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *EventValidatorVotingPowerChange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
 	var l int
 	_ = l
-	if len(m.ValidatorKeys) > 0 {
-		for _, e := range m.ValidatorKeys {
-			l = e.Size()
-			n += 1 + l + sovStake(uint64(l))
+	if m.VotingPower != nil {
+		{
+			size, err := m.VotingPower.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintStake(dAtA, i, uint64(size))
 		}
+		i--
+		dAtA[i] = 0x12
 	}
-	return n
+	if m.IdentityKey != nil {
+		{
+			size, err := m.IdentityKey.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintStake(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
 }
 
-func (m *FundingStream) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if m.Recipient != nil {
-		n += m.Recipient.Size()
+func (m *EventValidatorBondingStateChange) 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 n
+	return dAtA[:n], nil
 }
 
-func (m *FundingStream_ToAddress_) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if m.ToAddress != nil {
-		l = m.ToAddress.Size()
-		n += 1 + l + sovStake(uint64(l))
-	}
-	return n
+func (m *EventValidatorBondingStateChange) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
 }
-func (m *FundingStream_ToCommunityPool_) Size() (n int) {
-	if m == nil {
-		return 0
-	}
+
+func (m *EventValidatorBondingStateChange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
 	var l int
 	_ = l
-	if m.ToCommunityPool != nil {
-		l = m.ToCommunityPool.Size()
-		n += 1 + l + sovStake(uint64(l))
+	if m.BondingState != nil {
+		{
+			size, err := m.BondingState.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintStake(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x12
 	}
-	return n
+	if m.IdentityKey != nil {
+		{
+			size, err := m.IdentityKey.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintStake(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
 }
-func (m *FundingStream_ToAddress) Size() (n int) {
-	if m == nil {
-		return 0
+
+func (m *EventRateDataChange) 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 *EventRateDataChange) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *EventRateDataChange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
 	var l int
 	_ = l
-	l = len(m.Address)
-	if l > 0 {
-		n += 1 + l + sovStake(uint64(l))
+	if m.RateData != nil {
+		{
+			size, err := m.RateData.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintStake(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x12
 	}
-	if m.RateBps != 0 {
-		n += 1 + sovStake(uint64(m.RateBps))
+	if m.IdentityKey != nil {
+		{
+			size, err := m.IdentityKey.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintStake(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
 	}
-	return n
+	return len(dAtA) - i, nil
 }
 
-func (m *FundingStream_ToCommunityPool) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if m.RateBps != 0 {
-		n += 1 + sovStake(uint64(m.RateBps))
+func (m *EventValidatorDefinitionUpload) 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 n
+	return dAtA[:n], nil
 }
 
-func (m *RateData) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if m.IdentityKey != nil {
-		l = m.IdentityKey.Size()
-		n += 1 + l + sovStake(uint64(l))
-	}
-	if m.EpochIndex != 0 {
-		n += 1 + sovStake(uint64(m.EpochIndex))
-	}
-	if m.ValidatorRewardRate != nil {
-		l = m.ValidatorRewardRate.Size()
-		n += 1 + l + sovStake(uint64(l))
-	}
-	if m.ValidatorExchangeRate != nil {
-		l = m.ValidatorExchangeRate.Size()
-		n += 1 + l + sovStake(uint64(l))
-	}
-	return n
+func (m *EventValidatorDefinitionUpload) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *BaseRateData) Size() (n int) {
-	if m == nil {
-		return 0
-	}
+func (m *EventValidatorDefinitionUpload) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
 	var l int
 	_ = l
-	if m.EpochIndex != 0 {
-		n += 1 + sovStake(uint64(m.EpochIndex))
-	}
-	if m.BaseRewardRate != nil {
-		l = m.BaseRewardRate.Size()
-		n += 1 + l + sovStake(uint64(l))
-	}
-	if m.BaseExchangeRate != nil {
-		l = m.BaseExchangeRate.Size()
-		n += 1 + l + sovStake(uint64(l))
+	if m.Validator != nil {
+		{
+			size, err := m.Validator.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintStake(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
 	}
-	return n
+	return len(dAtA) - i, nil
 }
 
-func (m *ValidatorStatus) Size() (n int) {
-	if m == nil {
-		return 0
+func (m *EventValidatorMissedBlock) 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 *EventValidatorMissedBlock) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *EventValidatorMissedBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
 	var l int
 	_ = l
 	if m.IdentityKey != nil {
-		l = m.IdentityKey.Size()
-		n += 1 + l + sovStake(uint64(l))
-	}
-	if m.State != nil {
-		l = m.State.Size()
-		n += 1 + l + sovStake(uint64(l))
-	}
-	if m.VotingPower != nil {
-		l = m.VotingPower.Size()
-		n += 1 + l + sovStake(uint64(l))
-	}
-	if m.BondingState != nil {
-		l = m.BondingState.Size()
-		n += 1 + l + sovStake(uint64(l))
+		{
+			size, err := m.IdentityKey.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintStake(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
 	}
-	return n
+	return len(dAtA) - i, nil
 }
 
-func (m *BondingState) Size() (n int) {
-	if m == nil {
-		return 0
+func (m *EventDelegate) 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 *EventDelegate) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *EventDelegate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
 	var l int
 	_ = l
-	if m.State != 0 {
-		n += 1 + sovStake(uint64(m.State))
-	}
-	if m.UnbondsAtEpoch != 0 {
-		n += 1 + sovStake(uint64(m.UnbondsAtEpoch))
+	if m.Amount != nil {
+		{
+			size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintStake(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x1a
 	}
-	if m.UnbondsAtHeight != 0 {
-		n += 1 + sovStake(uint64(m.UnbondsAtHeight))
+	if m.IdentityKey != nil {
+		{
+			size, err := m.IdentityKey.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintStake(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
 	}
-	return n
+	return len(dAtA) - i, nil
 }
 
-func (m *ValidatorState) Size() (n int) {
-	if m == nil {
-		return 0
+func (m *EventUndelegate) 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 *EventUndelegate) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *EventUndelegate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
 	var l int
 	_ = l
-	if m.State != 0 {
-		n += 1 + sovStake(uint64(m.State))
+	if m.Amount != nil {
+		{
+			size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintStake(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x1a
 	}
-	return n
+	if m.IdentityKey != nil {
+		{
+			size, err := m.IdentityKey.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintStake(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
 }
 
-func (m *ValidatorInfo) Size() (n int) {
-	if m == nil {
-		return 0
+func (m *EventSlashingPenaltyApplied) 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 *EventSlashingPenaltyApplied) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *EventSlashingPenaltyApplied) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
 	var l int
 	_ = l
-	if m.Validator != nil {
-		l = m.Validator.Size()
-		n += 1 + l + sovStake(uint64(l))
+	if m.NewPenalty != nil {
+		{
+			size, err := m.NewPenalty.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintStake(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x1a
 	}
-	if m.Status != nil {
-		l = m.Status.Size()
-		n += 1 + l + sovStake(uint64(l))
+	if m.EpochIndex != 0 {
+		i = encodeVarintStake(dAtA, i, uint64(m.EpochIndex))
+		i--
+		dAtA[i] = 0x10
 	}
-	if m.RateData != nil {
-		l = m.RateData.Size()
-		n += 1 + l + sovStake(uint64(l))
+	if m.IdentityKey != nil {
+		{
+			size, err := m.IdentityKey.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintStake(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
 	}
-	return n
+	return len(dAtA) - i, nil
 }
 
-func (m *ValidatorDefinition) Size() (n int) {
+func encodeVarintStake(dAtA []byte, offset int, v uint64) int {
+	offset -= sovStake(v)
+	base := offset
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return base
+}
+func (m *ZKUndelegateClaimProof) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.Validator != nil {
-		l = m.Validator.Size()
-		n += 1 + l + sovStake(uint64(l))
-	}
-	l = len(m.AuthSig)
+	l = len(m.Inner)
 	if l > 0 {
 		n += 1 + l + sovStake(uint64(l))
 	}
 	return n
 }
 
-func (m *Delegate) Size() (n int) {
+func (m *Validator) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.ValidatorIdentity != nil {
-		l = m.ValidatorIdentity.Size()
+	if m.IdentityKey != nil {
+		l = m.IdentityKey.Size()
 		n += 1 + l + sovStake(uint64(l))
 	}
-	if m.EpochIndex != 0 {
-		n += 1 + sovStake(uint64(m.EpochIndex))
-	}
-	if m.UnbondedAmount != nil {
-		l = m.UnbondedAmount.Size()
+	l = len(m.ConsensusKey)
+	if l > 0 {
 		n += 1 + l + sovStake(uint64(l))
 	}
-	if m.DelegationAmount != nil {
-		l = m.DelegationAmount.Size()
+	l = len(m.Name)
+	if l > 0 {
 		n += 1 + l + sovStake(uint64(l))
 	}
-	return n
-}
-
-func (m *Undelegate) Size() (n int) {
-	if m == nil {
-		return 0
+	l = len(m.Website)
+	if l > 0 {
+		n += 1 + l + sovStake(uint64(l))
 	}
-	var l int
-	_ = l
-	if m.ValidatorIdentity != nil {
-		l = m.ValidatorIdentity.Size()
+	l = len(m.Description)
+	if l > 0 {
 		n += 1 + l + sovStake(uint64(l))
 	}
-	if m.StartEpochIndex != 0 {
-		n += 1 + sovStake(uint64(m.StartEpochIndex))
+	if len(m.FundingStreams) > 0 {
+		for _, e := range m.FundingStreams {
+			l = e.Size()
+			n += 1 + l + sovStake(uint64(l))
+		}
 	}
-	if m.UnbondedAmount != nil {
-		l = m.UnbondedAmount.Size()
-		n += 1 + l + sovStake(uint64(l))
+	if m.SequenceNumber != 0 {
+		n += 1 + sovStake(uint64(m.SequenceNumber))
 	}
-	if m.DelegationAmount != nil {
-		l = m.DelegationAmount.Size()
-		n += 1 + l + sovStake(uint64(l))
+	if m.Enabled {
+		n += 2
 	}
-	if m.FromEpoch != nil {
-		l = m.FromEpoch.Size()
+	if m.GovernanceKey != nil {
+		l = m.GovernanceKey.Size()
 		n += 1 + l + sovStake(uint64(l))
 	}
 	return n
 }
 
-func (m *UndelegateClaim) Size() (n int) {
+func (m *ValidatorList) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.Body != nil {
-		l = m.Body.Size()
-		n += 1 + l + sovStake(uint64(l))
-	}
-	l = len(m.Proof)
-	if l > 0 {
-		n += 1 + l + sovStake(uint64(l))
+	if len(m.ValidatorKeys) > 0 {
+		for _, e := range m.ValidatorKeys {
+			l = e.Size()
+			n += 1 + l + sovStake(uint64(l))
+		}
 	}
 	return n
 }
 
-func (m *UndelegateClaimBody) Size() (n int) {
+func (m *FundingStream) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.ValidatorIdentity != nil {
-		l = m.ValidatorIdentity.Size()
-		n += 1 + l + sovStake(uint64(l))
-	}
-	if m.StartEpochIndex != 0 {
-		n += 1 + sovStake(uint64(m.StartEpochIndex))
-	}
-	if m.Penalty != nil {
-		l = m.Penalty.Size()
-		n += 1 + l + sovStake(uint64(l))
-	}
-	if m.BalanceCommitment != nil {
-		l = m.BalanceCommitment.Size()
-		n += 1 + l + sovStake(uint64(l))
-	}
-	if m.UnbondingStartHeight != 0 {
-		n += 1 + sovStake(uint64(m.UnbondingStartHeight))
+	if m.Recipient != nil {
+		n += m.Recipient.Size()
 	}
 	return n
 }
 
-func (m *UndelegateClaimPlan) Size() (n int) {
+func (m *FundingStream_ToAddress_) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.ValidatorIdentity != nil {
-		l = m.ValidatorIdentity.Size()
-		n += 1 + l + sovStake(uint64(l))
-	}
-	if m.StartEpochIndex != 0 {
-		n += 1 + sovStake(uint64(m.StartEpochIndex))
-	}
-	if m.Penalty != nil {
-		l = m.Penalty.Size()
-		n += 1 + l + sovStake(uint64(l))
-	}
-	if m.UnbondingAmount != nil {
-		l = m.UnbondingAmount.Size()
-		n += 1 + l + sovStake(uint64(l))
-	}
-	l = len(m.BalanceBlinding)
-	if l > 0 {
-		n += 1 + l + sovStake(uint64(l))
-	}
-	l = len(m.ProofBlindingR)
-	if l > 0 {
-		n += 1 + l + sovStake(uint64(l))
-	}
-	l = len(m.ProofBlindingS)
-	if l > 0 {
+	if m.ToAddress != nil {
+		l = m.ToAddress.Size()
 		n += 1 + l + sovStake(uint64(l))
 	}
-	if m.UnbondingStartHeight != 0 {
-		n += 1 + sovStake(uint64(m.UnbondingStartHeight))
-	}
 	return n
 }
-
-func (m *DelegationChanges) Size() (n int) {
+func (m *FundingStream_ToCommunityPool_) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if len(m.Delegations) > 0 {
-		for _, e := range m.Delegations {
-			l = e.Size()
-			n += 1 + l + sovStake(uint64(l))
-		}
-	}
-	if len(m.Undelegations) > 0 {
-		for _, e := range m.Undelegations {
-			l = e.Size()
-			n += 1 + l + sovStake(uint64(l))
-		}
+	if m.ToCommunityPool != nil {
+		l = m.ToCommunityPool.Size()
+		n += 1 + l + sovStake(uint64(l))
 	}
 	return n
 }
-
-func (m *Uptime) Size() (n int) {
+func (m *FundingStream_ToAddress) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.AsOfBlockHeight != 0 {
-		n += 1 + sovStake(uint64(m.AsOfBlockHeight))
-	}
-	if m.WindowLen != 0 {
-		n += 1 + sovStake(uint64(m.WindowLen))
-	}
-	l = len(m.Bitvec)
+	l = len(m.Address)
 	if l > 0 {
 		n += 1 + l + sovStake(uint64(l))
 	}
-	return n
-}
-
-func (m *CurrentConsensusKeys) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if len(m.ConsensusKeys) > 0 {
-		for _, e := range m.ConsensusKeys {
-			l = e.Size()
-			n += 1 + l + sovStake(uint64(l))
-		}
+	if m.RateBps != 0 {
+		n += 1 + sovStake(uint64(m.RateBps))
 	}
 	return n
 }
 
-func (m *Penalty) Size() (n int) {
+func (m *FundingStream_ToCommunityPool) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	l = len(m.Inner)
-	if l > 0 {
-		n += 1 + l + sovStake(uint64(l))
+	if m.RateBps != 0 {
+		n += 1 + sovStake(uint64(m.RateBps))
 	}
 	return n
 }
 
-func (m *GetValidatorInfoRequest) Size() (n int) {
+func (m *RateData) Size() (n int) {
 	if m == nil {
 		return 0
 	}
@@ -5115,246 +5677,1143 @@ func (m *GetValidatorInfoRequest) Size() (n int) {
 		l = m.IdentityKey.Size()
 		n += 1 + l + sovStake(uint64(l))
 	}
+	if m.EpochIndex != 0 {
+		n += 1 + sovStake(uint64(m.EpochIndex))
+	}
+	if m.ValidatorRewardRate != nil {
+		l = m.ValidatorRewardRate.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	if m.ValidatorExchangeRate != nil {
+		l = m.ValidatorExchangeRate.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
 	return n
 }
 
-func (m *GetValidatorInfoResponse) Size() (n int) {
+func (m *BaseRateData) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.ValidatorInfo != nil {
-		l = m.ValidatorInfo.Size()
+	if m.EpochIndex != 0 {
+		n += 1 + sovStake(uint64(m.EpochIndex))
+	}
+	if m.BaseRewardRate != nil {
+		l = m.BaseRewardRate.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	if m.BaseExchangeRate != nil {
+		l = m.BaseExchangeRate.Size()
 		n += 1 + l + sovStake(uint64(l))
 	}
 	return n
 }
 
-func (m *ValidatorInfoRequest) Size() (n int) {
+func (m *ValidatorStatus) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.ShowInactive {
-		n += 2
+	if m.IdentityKey != nil {
+		l = m.IdentityKey.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	if m.State != nil {
+		l = m.State.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	if m.VotingPower != nil {
+		l = m.VotingPower.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	if m.BondingState != nil {
+		l = m.BondingState.Size()
+		n += 1 + l + sovStake(uint64(l))
 	}
 	return n
 }
 
-func (m *ValidatorInfoResponse) Size() (n int) {
+func (m *BondingState) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.ValidatorInfo != nil {
-		l = m.ValidatorInfo.Size()
-		n += 1 + l + sovStake(uint64(l))
+	if m.State != 0 {
+		n += 1 + sovStake(uint64(m.State))
+	}
+	if m.UnbondsAtEpoch != 0 {
+		n += 1 + sovStake(uint64(m.UnbondsAtEpoch))
+	}
+	if m.UnbondsAtHeight != 0 {
+		n += 1 + sovStake(uint64(m.UnbondsAtHeight))
 	}
 	return n
 }
 
-func (m *ValidatorStatusRequest) Size() (n int) {
+func (m *ValidatorState) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.IdentityKey != nil {
-		l = m.IdentityKey.Size()
-		n += 1 + l + sovStake(uint64(l))
+	if m.State != 0 {
+		n += 1 + sovStake(uint64(m.State))
 	}
 	return n
 }
 
-func (m *ValidatorStatusResponse) Size() (n int) {
+func (m *ValidatorInfo) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
+	if m.Validator != nil {
+		l = m.Validator.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
 	if m.Status != nil {
 		l = m.Status.Size()
 		n += 1 + l + sovStake(uint64(l))
 	}
+	if m.RateData != nil {
+		l = m.RateData.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
 	return n
 }
 
-func (m *ValidatorPenaltyRequest) Size() (n int) {
+func (m *ValidatorDefinition) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.IdentityKey != nil {
-		l = m.IdentityKey.Size()
+	if m.Validator != nil {
+		l = m.Validator.Size()
 		n += 1 + l + sovStake(uint64(l))
 	}
-	if m.StartEpochIndex != 0 {
-		n += 1 + sovStake(uint64(m.StartEpochIndex))
-	}
-	if m.EndEpochIndex != 0 {
-		n += 1 + sovStake(uint64(m.EndEpochIndex))
+	l = len(m.AuthSig)
+	if l > 0 {
+		n += 1 + l + sovStake(uint64(l))
 	}
 	return n
 }
 
-func (m *ValidatorPenaltyResponse) Size() (n int) {
+func (m *Delegate) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.Penalty != nil {
-		l = m.Penalty.Size()
+	if m.ValidatorIdentity != nil {
+		l = m.ValidatorIdentity.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	if m.EpochIndex != 0 {
+		n += 1 + sovStake(uint64(m.EpochIndex))
+	}
+	if m.UnbondedAmount != nil {
+		l = m.UnbondedAmount.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	if m.DelegationAmount != nil {
+		l = m.DelegationAmount.Size()
 		n += 1 + l + sovStake(uint64(l))
 	}
 	return n
 }
 
-func (m *CurrentValidatorRateRequest) Size() (n int) {
+func (m *Undelegate) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.IdentityKey != nil {
-		l = m.IdentityKey.Size()
+	if m.ValidatorIdentity != nil {
+		l = m.ValidatorIdentity.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	if m.StartEpochIndex != 0 {
+		n += 1 + sovStake(uint64(m.StartEpochIndex))
+	}
+	if m.UnbondedAmount != nil {
+		l = m.UnbondedAmount.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	if m.DelegationAmount != nil {
+		l = m.DelegationAmount.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	if m.FromEpoch != nil {
+		l = m.FromEpoch.Size()
 		n += 1 + l + sovStake(uint64(l))
 	}
 	return n
 }
 
-func (m *CurrentValidatorRateResponse) Size() (n int) {
+func (m *UndelegateClaim) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.Data != nil {
-		l = m.Data.Size()
+	if m.Body != nil {
+		l = m.Body.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	l = len(m.Proof)
+	if l > 0 {
 		n += 1 + l + sovStake(uint64(l))
 	}
 	return n
 }
 
-func (m *ValidatorUptimeRequest) Size() (n int) {
+func (m *UndelegateClaimBody) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.IdentityKey != nil {
-		l = m.IdentityKey.Size()
+	if m.ValidatorIdentity != nil {
+		l = m.ValidatorIdentity.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	if m.StartEpochIndex != 0 {
+		n += 1 + sovStake(uint64(m.StartEpochIndex))
+	}
+	if m.Penalty != nil {
+		l = m.Penalty.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	if m.BalanceCommitment != nil {
+		l = m.BalanceCommitment.Size()
 		n += 1 + l + sovStake(uint64(l))
 	}
+	if m.UnbondingStartHeight != 0 {
+		n += 1 + sovStake(uint64(m.UnbondingStartHeight))
+	}
 	return n
 }
 
-func (m *ValidatorUptimeResponse) Size() (n int) {
+func (m *UndelegateClaimPlan) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.Uptime != nil {
-		l = m.Uptime.Size()
+	if m.ValidatorIdentity != nil {
+		l = m.ValidatorIdentity.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	if m.StartEpochIndex != 0 {
+		n += 1 + sovStake(uint64(m.StartEpochIndex))
+	}
+	if m.Penalty != nil {
+		l = m.Penalty.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	if m.UnbondingAmount != nil {
+		l = m.UnbondingAmount.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	l = len(m.BalanceBlinding)
+	if l > 0 {
+		n += 1 + l + sovStake(uint64(l))
+	}
+	l = len(m.ProofBlindingR)
+	if l > 0 {
+		n += 1 + l + sovStake(uint64(l))
+	}
+	l = len(m.ProofBlindingS)
+	if l > 0 {
 		n += 1 + l + sovStake(uint64(l))
 	}
+	if m.UnbondingStartHeight != 0 {
+		n += 1 + sovStake(uint64(m.UnbondingStartHeight))
+	}
 	return n
 }
 
-func (m *StakeParameters) Size() (n int) {
+func (m *DelegationChanges) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.UnbondingEpochs != 0 {
-		n += 1 + sovStake(uint64(m.UnbondingEpochs))
+	if len(m.Delegations) > 0 {
+		for _, e := range m.Delegations {
+			l = e.Size()
+			n += 1 + l + sovStake(uint64(l))
+		}
 	}
-	if m.ActiveValidatorLimit != 0 {
-		n += 1 + sovStake(uint64(m.ActiveValidatorLimit))
+	if len(m.Undelegations) > 0 {
+		for _, e := range m.Undelegations {
+			l = e.Size()
+			n += 1 + l + sovStake(uint64(l))
+		}
 	}
-	if m.BaseRewardRate != 0 {
-		n += 1 + sovStake(uint64(m.BaseRewardRate))
+	return n
+}
+
+func (m *Uptime) Size() (n int) {
+	if m == nil {
+		return 0
 	}
-	if m.SlashingPenaltyMisbehavior != 0 {
-		n += 1 + sovStake(uint64(m.SlashingPenaltyMisbehavior))
+	var l int
+	_ = l
+	if m.AsOfBlockHeight != 0 {
+		n += 1 + sovStake(uint64(m.AsOfBlockHeight))
 	}
-	if m.SlashingPenaltyDowntime != 0 {
-		n += 1 + sovStake(uint64(m.SlashingPenaltyDowntime))
+	if m.WindowLen != 0 {
+		n += 1 + sovStake(uint64(m.WindowLen))
 	}
-	if m.SignedBlocksWindowLen != 0 {
-		n += 1 + sovStake(uint64(m.SignedBlocksWindowLen))
+	l = len(m.Bitvec)
+	if l > 0 {
+		n += 1 + l + sovStake(uint64(l))
 	}
-	if m.MissedBlocksMaximum != 0 {
-		n += 1 + sovStake(uint64(m.MissedBlocksMaximum))
+	return n
+}
+
+func (m *CurrentConsensusKeys) Size() (n int) {
+	if m == nil {
+		return 0
 	}
-	if m.MinValidatorStake != nil {
-		l = m.MinValidatorStake.Size()
+	var l int
+	_ = l
+	if len(m.ConsensusKeys) > 0 {
+		for _, e := range m.ConsensusKeys {
+			l = e.Size()
+			n += 1 + l + sovStake(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *Penalty) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Inner)
+	if l > 0 {
 		n += 1 + l + sovStake(uint64(l))
 	}
-	if m.UnbondingDelay != 0 {
-		n += 1 + sovStake(uint64(m.UnbondingDelay))
+	return n
+}
+
+func (m *GetValidatorInfoRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.IdentityKey != nil {
+		l = m.IdentityKey.Size()
+		n += 1 + l + sovStake(uint64(l))
 	}
 	return n
 }
 
-func (m *GenesisContent) Size() (n int) {
+func (m *GetValidatorInfoResponse) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if m.StakeParams != nil {
-		l = m.StakeParams.Size()
+	if m.ValidatorInfo != nil {
+		l = m.ValidatorInfo.Size()
 		n += 1 + l + sovStake(uint64(l))
 	}
-	if len(m.Validators) > 0 {
-		for _, e := range m.Validators {
-			l = e.Size()
-			n += 1 + l + sovStake(uint64(l))
+	return n
+}
+
+func (m *ValidatorInfoRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.ShowInactive {
+		n += 2
+	}
+	return n
+}
+
+func (m *ValidatorInfoResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.ValidatorInfo != nil {
+		l = m.ValidatorInfo.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	return n
+}
+
+func (m *ValidatorStatusRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.IdentityKey != nil {
+		l = m.IdentityKey.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	return n
+}
+
+func (m *ValidatorStatusResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Status != nil {
+		l = m.Status.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	return n
+}
+
+func (m *ValidatorPenaltyRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.IdentityKey != nil {
+		l = m.IdentityKey.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	if m.StartEpochIndex != 0 {
+		n += 1 + sovStake(uint64(m.StartEpochIndex))
+	}
+	if m.EndEpochIndex != 0 {
+		n += 1 + sovStake(uint64(m.EndEpochIndex))
+	}
+	return n
+}
+
+func (m *ValidatorPenaltyResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Penalty != nil {
+		l = m.Penalty.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	return n
+}
+
+func (m *CurrentValidatorRateRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.IdentityKey != nil {
+		l = m.IdentityKey.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	return n
+}
+
+func (m *CurrentValidatorRateResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Data != nil {
+		l = m.Data.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	return n
+}
+
+func (m *ValidatorUptimeRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.IdentityKey != nil {
+		l = m.IdentityKey.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	return n
+}
+
+func (m *ValidatorUptimeResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Uptime != nil {
+		l = m.Uptime.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	return n
+}
+
+func (m *StakeParameters) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.UnbondingEpochs != 0 {
+		n += 1 + sovStake(uint64(m.UnbondingEpochs))
+	}
+	if m.ActiveValidatorLimit != 0 {
+		n += 1 + sovStake(uint64(m.ActiveValidatorLimit))
+	}
+	if m.BaseRewardRate != 0 {
+		n += 1 + sovStake(uint64(m.BaseRewardRate))
+	}
+	if m.SlashingPenaltyMisbehavior != 0 {
+		n += 1 + sovStake(uint64(m.SlashingPenaltyMisbehavior))
+	}
+	if m.SlashingPenaltyDowntime != 0 {
+		n += 1 + sovStake(uint64(m.SlashingPenaltyDowntime))
+	}
+	if m.SignedBlocksWindowLen != 0 {
+		n += 1 + sovStake(uint64(m.SignedBlocksWindowLen))
+	}
+	if m.MissedBlocksMaximum != 0 {
+		n += 1 + sovStake(uint64(m.MissedBlocksMaximum))
+	}
+	if m.MinValidatorStake != nil {
+		l = m.MinValidatorStake.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	if m.UnbondingDelay != 0 {
+		n += 1 + sovStake(uint64(m.UnbondingDelay))
+	}
+	return n
+}
+
+func (m *GenesisContent) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.StakeParams != nil {
+		l = m.StakeParams.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	if len(m.Validators) > 0 {
+		for _, e := range m.Validators {
+			l = e.Size()
+			n += 1 + l + sovStake(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *EventTombstoneValidator) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.EvidenceHeight != 0 {
+		n += 1 + sovStake(uint64(m.EvidenceHeight))
+	}
+	if m.CurrentHeight != 0 {
+		n += 1 + sovStake(uint64(m.CurrentHeight))
+	}
+	if m.IdentityKey != nil {
+		l = m.IdentityKey.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	l = len(m.Address)
+	if l > 0 {
+		n += 1 + l + sovStake(uint64(l))
+	}
+	if m.VotingPower != 0 {
+		n += 1 + sovStake(uint64(m.VotingPower))
+	}
+	return n
+}
+
+func (m *EventValidatorStateChange) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.IdentityKey != nil {
+		l = m.IdentityKey.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	if m.State != nil {
+		l = m.State.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	return n
+}
+
+func (m *EventValidatorVotingPowerChange) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.IdentityKey != nil {
+		l = m.IdentityKey.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	if m.VotingPower != nil {
+		l = m.VotingPower.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	return n
+}
+
+func (m *EventValidatorBondingStateChange) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.IdentityKey != nil {
+		l = m.IdentityKey.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	if m.BondingState != nil {
+		l = m.BondingState.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	return n
+}
+
+func (m *EventRateDataChange) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.IdentityKey != nil {
+		l = m.IdentityKey.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	if m.RateData != nil {
+		l = m.RateData.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	return n
+}
+
+func (m *EventValidatorDefinitionUpload) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Validator != nil {
+		l = m.Validator.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	return n
+}
+
+func (m *EventValidatorMissedBlock) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.IdentityKey != nil {
+		l = m.IdentityKey.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	return n
+}
+
+func (m *EventDelegate) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.IdentityKey != nil {
+		l = m.IdentityKey.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	if m.Amount != nil {
+		l = m.Amount.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	return n
+}
+
+func (m *EventUndelegate) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.IdentityKey != nil {
+		l = m.IdentityKey.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	if m.Amount != nil {
+		l = m.Amount.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	return n
+}
+
+func (m *EventSlashingPenaltyApplied) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.IdentityKey != nil {
+		l = m.IdentityKey.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	if m.EpochIndex != 0 {
+		n += 1 + sovStake(uint64(m.EpochIndex))
+	}
+	if m.NewPenalty != nil {
+		l = m.NewPenalty.Size()
+		n += 1 + l + sovStake(uint64(l))
+	}
+	return n
+}
+
+func sovStake(x uint64) (n int) {
+	return (math_bits.Len64(x|1) + 6) / 7
+}
+func sozStake(x uint64) (n int) {
+	return sovStake(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *ZKUndelegateClaimProof) 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 ErrIntOverflowStake
+			}
+			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: ZKUndelegateClaimProof: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ZKUndelegateClaimProof: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStake
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthStake
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStake
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...)
+			if m.Inner == nil {
+				m.Inner = []byte{}
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStake(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStake
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *Validator) 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 ErrIntOverflowStake
+			}
+			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: Validator: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Validator: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStake
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStake
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStake
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.IdentityKey == nil {
+				m.IdentityKey = &v1.IdentityKey{}
+			}
+			if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ConsensusKey", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStake
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthStake
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStake
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ConsensusKey = append(m.ConsensusKey[:0], dAtA[iNdEx:postIndex]...)
+			if m.ConsensusKey == nil {
+				m.ConsensusKey = []byte{}
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStake
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStake
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStake
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Name = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Website", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStake
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStake
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStake
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Website = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStake
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthStake
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStake
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Description = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 6:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field FundingStreams", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStake
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStake
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStake
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.FundingStreams = append(m.FundingStreams, &FundingStream{})
+			if err := m.FundingStreams[len(m.FundingStreams)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 7:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SequenceNumber", wireType)
+			}
+			m.SequenceNumber = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStake
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.SequenceNumber |= uint32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 8:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Enabled", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStake
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Enabled = bool(v != 0)
+		case 9:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field GovernanceKey", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStake
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStake
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStake
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.GovernanceKey == nil {
+				m.GovernanceKey = &v1.GovernanceKey{}
+			}
+			if err := m.GovernanceKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStake(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStake
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
 		}
 	}
-	return n
-}
 
-func (m *EventTombstoneValidator) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if m.EvidenceHeight != 0 {
-		n += 1 + sovStake(uint64(m.EvidenceHeight))
-	}
-	if m.CurrentHeight != 0 {
-		n += 1 + sovStake(uint64(m.CurrentHeight))
-	}
-	if m.IdentityKey != nil {
-		l = m.IdentityKey.Size()
-		n += 1 + l + sovStake(uint64(l))
-	}
-	l = len(m.Address)
-	if l > 0 {
-		n += 1 + l + sovStake(uint64(l))
-	}
-	if m.VotingPower != 0 {
-		n += 1 + sovStake(uint64(m.VotingPower))
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
 	}
-	return n
-}
-
-func sovStake(x uint64) (n int) {
-	return (math_bits.Len64(x|1) + 6) / 7
-}
-func sozStake(x uint64) (n int) {
-	return sovStake(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+	return nil
 }
-func (m *ZKUndelegateClaimProof) Unmarshal(dAtA []byte) error {
+func (m *ValidatorList) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -5377,17 +6836,17 @@ func (m *ZKUndelegateClaimProof) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ZKUndelegateClaimProof: wiretype end group for non-group")
+			return fmt.Errorf("proto: ValidatorList: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ZKUndelegateClaimProof: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: ValidatorList: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorKeys", wireType)
 			}
-			var byteLen int
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -5397,24 +6856,24 @@ func (m *ZKUndelegateClaimProof) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				byteLen |= int(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if byteLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthStake
 			}
-			postIndex := iNdEx + byteLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthStake
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...)
-			if m.Inner == nil {
-				m.Inner = []byte{}
+			m.ValidatorKeys = append(m.ValidatorKeys, &v1.IdentityKey{})
+			if err := m.ValidatorKeys[len(m.ValidatorKeys)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
 			}
 			iNdEx = postIndex
 		default:
@@ -5438,7 +6897,7 @@ func (m *ZKUndelegateClaimProof) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *Validator) Unmarshal(dAtA []byte) error {
+func (m *FundingStream) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -5461,15 +6920,15 @@ func (m *Validator) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: Validator: wiretype end group for non-group")
+			return fmt.Errorf("proto: FundingStream: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: Validator: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: FundingStream: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ToAddress", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -5496,18 +6955,17 @@ func (m *Validator) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.IdentityKey == nil {
-				m.IdentityKey = &v1.IdentityKey{}
-			}
-			if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			v := &FundingStream_ToAddress{}
+			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
+			m.Recipient = &FundingStream_ToAddress_{v}
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ConsensusKey", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ToCommunityPool", wireType)
 			}
-			var byteLen int
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -5517,29 +6975,80 @@ func (m *Validator) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				byteLen |= int(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if byteLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthStake
 			}
-			postIndex := iNdEx + byteLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthStake
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.ConsensusKey = append(m.ConsensusKey[:0], dAtA[iNdEx:postIndex]...)
-			if m.ConsensusKey == nil {
-				m.ConsensusKey = []byte{}
+			v := &FundingStream_ToCommunityPool{}
+			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
 			}
+			m.Recipient = &FundingStream_ToCommunityPool_{v}
 			iNdEx = postIndex
-		case 3:
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStake(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStake
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *FundingStream_ToAddress) 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 ErrIntOverflowStake
+			}
+			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: ToAddress: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ToAddress: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
 			}
 			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
@@ -5567,13 +7076,13 @@ func (m *Validator) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Name = string(dAtA[iNdEx:postIndex])
+			m.Address = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
-		case 4:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Website", wireType)
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RateBps", wireType)
 			}
-			var stringLen uint64
+			m.RateBps = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -5583,29 +7092,66 @@ func (m *Validator) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				m.RateBps |= uint32(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthStake
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStake(dAtA[iNdEx:])
+			if err != nil {
+				return err
 			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
 				return ErrInvalidLengthStake
 			}
-			if postIndex > l {
+			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Website = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 5:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *FundingStream_ToCommunityPool) 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 ErrIntOverflowStake
 			}
-			var stringLen uint64
+			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: ToCommunityPool: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ToCommunityPool: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RateBps", wireType)
+			}
+			m.RateBps = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -5615,27 +7161,64 @@ func (m *Validator) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				m.RateBps |= uint32(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthStake
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStake(dAtA[iNdEx:])
+			if err != nil {
+				return err
 			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
 				return ErrInvalidLengthStake
 			}
-			if postIndex > l {
+			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Description = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 6:
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *RateData) 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 ErrIntOverflowStake
+			}
+			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: RateData: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: RateData: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field FundingStreams", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -5662,35 +7245,18 @@ func (m *Validator) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.FundingStreams = append(m.FundingStreams, &FundingStream{})
-			if err := m.FundingStreams[len(m.FundingStreams)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if m.IdentityKey == nil {
+				m.IdentityKey = &v1.IdentityKey{}
+			}
+			if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
-		case 7:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field SequenceNumber", wireType)
-			}
-			m.SequenceNumber = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStake
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.SequenceNumber |= uint32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 8:
+		case 2:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Enabled", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
 			}
-			var v int
+			m.EpochIndex = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -5700,15 +7266,14 @@ func (m *Validator) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= int(b&0x7F) << shift
+				m.EpochIndex |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			m.Enabled = bool(v != 0)
-		case 9:
+		case 4:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field GovernanceKey", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorRewardRate", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -5735,66 +7300,16 @@ func (m *Validator) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.GovernanceKey == nil {
-				m.GovernanceKey = &v1.GovernanceKey{}
+			if m.ValidatorRewardRate == nil {
+				m.ValidatorRewardRate = &v11.Amount{}
 			}
-			if err := m.GovernanceKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.ValidatorRewardRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipStake(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthStake
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *ValidatorList) 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 ErrIntOverflowStake
-			}
-			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: ValidatorList: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ValidatorList: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
+		case 5:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorKeys", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorExchangeRate", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -5821,8 +7336,10 @@ func (m *ValidatorList) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.ValidatorKeys = append(m.ValidatorKeys, &v1.IdentityKey{})
-			if err := m.ValidatorKeys[len(m.ValidatorKeys)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if m.ValidatorExchangeRate == nil {
+				m.ValidatorExchangeRate = &v11.Amount{}
+			}
+			if err := m.ValidatorExchangeRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -5847,7 +7364,7 @@ func (m *ValidatorList) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *FundingStream) Unmarshal(dAtA []byte) error {
+func (m *BaseRateData) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -5870,15 +7387,34 @@ func (m *FundingStream) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: FundingStream: wiretype end group for non-group")
+			return fmt.Errorf("proto: BaseRateData: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: FundingStream: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: BaseRateData: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
+			}
+			m.EpochIndex = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStake
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.EpochIndex |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ToAddress", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field BaseRewardRate", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -5905,15 +7441,16 @@ func (m *FundingStream) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			v := &FundingStream_ToAddress{}
-			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if m.BaseRewardRate == nil {
+				m.BaseRewardRate = &v11.Amount{}
+			}
+			if err := m.BaseRewardRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
-			m.Recipient = &FundingStream_ToAddress_{v}
 			iNdEx = postIndex
-		case 2:
+		case 3:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ToCommunityPool", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field BaseExchangeRate", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -5940,11 +7477,12 @@ func (m *FundingStream) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			v := &FundingStream_ToCommunityPool{}
-			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if m.BaseExchangeRate == nil {
+				m.BaseExchangeRate = &v11.Amount{}
+			}
+			if err := m.BaseExchangeRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
-			m.Recipient = &FundingStream_ToCommunityPool_{v}
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -5967,7 +7505,7 @@ func (m *FundingStream) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *FundingStream_ToAddress) Unmarshal(dAtA []byte) error {
+func (m *ValidatorStatus) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -5990,17 +7528,17 @@ func (m *FundingStream_ToAddress) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ToAddress: wiretype end group for non-group")
+			return fmt.Errorf("proto: ValidatorStatus: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ToAddress: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: ValidatorStatus: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType)
 			}
-			var stringLen uint64
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -6010,29 +7548,33 @@ func (m *FundingStream_ToAddress) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthStake
 			}
-			postIndex := iNdEx + intStringLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthStake
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Address = string(dAtA[iNdEx:postIndex])
+			if m.IdentityKey == nil {
+				m.IdentityKey = &v1.IdentityKey{}
+			}
+			if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
 			iNdEx = postIndex
 		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field RateBps", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
 			}
-			m.RateBps = 0
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -6042,66 +7584,69 @@ func (m *FundingStream_ToAddress) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.RateBps |= uint32(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-		default:
-			iNdEx = preIndex
-			skippy, err := skipStake(dAtA[iNdEx:])
-			if err != nil {
-				return err
+			if msglen < 0 {
+				return ErrInvalidLengthStake
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
 				return ErrInvalidLengthStake
 			}
-			if (iNdEx + skippy) > l {
+			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *FundingStream_ToCommunityPool) 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 ErrIntOverflowStake
+			if m.State == nil {
+				m.State = &ValidatorState{}
 			}
-			if iNdEx >= l {
+			if err := m.State.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field VotingPower", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStake
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStake
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStake
+			}
+			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
+			if m.VotingPower == nil {
+				m.VotingPower = &v11.Amount{}
 			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: ToCommunityPool: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ToCommunityPool: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field RateBps", wireType)
+			if err := m.VotingPower.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
 			}
-			m.RateBps = 0
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field BondingState", wireType)
+			}
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -6111,11 +7656,28 @@ func (m *FundingStream_ToCommunityPool) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.RateBps |= uint32(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
+			if msglen < 0 {
+				return ErrInvalidLengthStake
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStake
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.BondingState == nil {
+				m.BondingState = &BondingState{}
+			}
+			if err := m.BondingState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipStake(dAtA[iNdEx:])
@@ -6137,7 +7699,7 @@ func (m *FundingStream_ToCommunityPool) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *RateData) Unmarshal(dAtA []byte) error {
+func (m *BondingState) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -6160,17 +7722,17 @@ func (m *RateData) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: RateData: wiretype end group for non-group")
+			return fmt.Errorf("proto: BondingState: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: RateData: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: BondingState: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
 			}
-			var msglen int
+			m.State = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -6180,33 +7742,16 @@ func (m *RateData) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				m.State |= BondingState_BondingStateEnum(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
-				return ErrInvalidLengthStake
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthStake
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.IdentityKey == nil {
-				m.IdentityKey = &v1.IdentityKey{}
-			}
-			if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
 		case 2:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field UnbondsAtEpoch", wireType)
 			}
-			m.EpochIndex = 0
+			m.UnbondsAtEpoch = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -6216,16 +7761,16 @@ func (m *RateData) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.EpochIndex |= uint64(b&0x7F) << shift
+				m.UnbondsAtEpoch |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-		case 4:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorRewardRate", wireType)
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field UnbondsAtHeight", wireType)
 			}
-			var msglen int
+			m.UnbondsAtHeight = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -6235,33 +7780,66 @@ func (m *RateData) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				m.UnbondsAtHeight |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
-				return ErrInvalidLengthStake
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStake(dAtA[iNdEx:])
+			if err != nil {
+				return err
 			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
 				return ErrInvalidLengthStake
 			}
-			if postIndex > l {
+			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.ValidatorRewardRate == nil {
-				m.ValidatorRewardRate = &v11.Amount{}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *ValidatorState) 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 ErrIntOverflowStake
 			}
-			if err := m.ValidatorRewardRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
 			}
-			iNdEx = postIndex
-		case 5:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorExchangeRate", wireType)
+			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: ValidatorState: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ValidatorState: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
 			}
-			var msglen int
+			m.State = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -6271,28 +7849,11 @@ func (m *RateData) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				m.State |= ValidatorState_ValidatorStateEnum(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
-				return ErrInvalidLengthStake
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthStake
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.ValidatorExchangeRate == nil {
-				m.ValidatorExchangeRate = &v11.Amount{}
-			}
-			if err := m.ValidatorExchangeRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipStake(dAtA[iNdEx:])
@@ -6314,7 +7875,7 @@ func (m *RateData) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *BaseRateData) Unmarshal(dAtA []byte) error {
+func (m *ValidatorInfo) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -6337,17 +7898,17 @@ func (m *BaseRateData) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: BaseRateData: wiretype end group for non-group")
+			return fmt.Errorf("proto: ValidatorInfo: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: BaseRateData: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: ValidatorInfo: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Validator", wireType)
 			}
-			m.EpochIndex = 0
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -6357,14 +7918,31 @@ func (m *BaseRateData) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.EpochIndex |= uint64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
+			if msglen < 0 {
+				return ErrInvalidLengthStake
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStake
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Validator == nil {
+				m.Validator = &Validator{}
+			}
+			if err := m.Validator.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field BaseRewardRate", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -6391,16 +7969,16 @@ func (m *BaseRateData) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.BaseRewardRate == nil {
-				m.BaseRewardRate = &v11.Amount{}
+			if m.Status == nil {
+				m.Status = &ValidatorStatus{}
 			}
-			if err := m.BaseRewardRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field BaseExchangeRate", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field RateData", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -6427,10 +8005,10 @@ func (m *BaseRateData) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.BaseExchangeRate == nil {
-				m.BaseExchangeRate = &v11.Amount{}
+			if m.RateData == nil {
+				m.RateData = &RateData{}
 			}
-			if err := m.BaseExchangeRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.RateData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -6455,7 +8033,7 @@ func (m *BaseRateData) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ValidatorStatus) Unmarshal(dAtA []byte) error {
+func (m *ValidatorDefinition) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -6478,15 +8056,15 @@ func (m *ValidatorStatus) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ValidatorStatus: wiretype end group for non-group")
+			return fmt.Errorf("proto: ValidatorDefinition: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ValidatorStatus: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: ValidatorDefinition: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Validator", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -6513,90 +8091,18 @@ func (m *ValidatorStatus) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.IdentityKey == nil {
-				m.IdentityKey = &v1.IdentityKey{}
+			if m.Validator == nil {
+				m.Validator = &Validator{}
 			}
-			if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.Validator.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStake
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthStake
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthStake
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.State == nil {
-				m.State = &ValidatorState{}
-			}
-			if err := m.State.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field VotingPower", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStake
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthStake
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthStake
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.VotingPower == nil {
-				m.VotingPower = &v11.Amount{}
-			}
-			if err := m.VotingPower.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 4:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field BondingState", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field AuthSig", wireType)
 			}
-			var msglen int
+			var byteLen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -6606,26 +8112,24 @@ func (m *ValidatorStatus) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				byteLen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			if byteLen < 0 {
 				return ErrInvalidLengthStake
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + byteLen
 			if postIndex < 0 {
 				return ErrInvalidLengthStake
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.BondingState == nil {
-				m.BondingState = &BondingState{}
-			}
-			if err := m.BondingState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
+			m.AuthSig = append(m.AuthSig[:0], dAtA[iNdEx:postIndex]...)
+			if m.AuthSig == nil {
+				m.AuthSig = []byte{}
 			}
 			iNdEx = postIndex
 		default:
@@ -6649,7 +8153,7 @@ func (m *ValidatorStatus) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *BondingState) Unmarshal(dAtA []byte) error {
+func (m *Delegate) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -6672,17 +8176,17 @@ func (m *BondingState) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: BondingState: wiretype end group for non-group")
+			return fmt.Errorf("proto: Delegate: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: BondingState: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: Delegate: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorIdentity", wireType)
 			}
-			m.State = 0
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -6692,16 +8196,33 @@ func (m *BondingState) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.State |= BondingState_BondingStateEnum(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
+			if msglen < 0 {
+				return ErrInvalidLengthStake
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStake
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.ValidatorIdentity == nil {
+				m.ValidatorIdentity = &v1.IdentityKey{}
+			}
+			if err := m.ValidatorIdentity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		case 2:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field UnbondsAtEpoch", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
 			}
-			m.UnbondsAtEpoch = 0
+			m.EpochIndex = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -6711,16 +8232,52 @@ func (m *BondingState) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.UnbondsAtEpoch |= uint64(b&0x7F) << shift
+				m.EpochIndex |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
 		case 3:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field UnbondsAtHeight", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field UnbondedAmount", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStake
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStake
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStake
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.UnbondedAmount == nil {
+				m.UnbondedAmount = &v11.Amount{}
+			}
+			if err := m.UnbondedAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field DelegationAmount", wireType)
 			}
-			m.UnbondsAtHeight = 0
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -6730,11 +8287,28 @@ func (m *BondingState) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.UnbondsAtHeight |= uint64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
+			if msglen < 0 {
+				return ErrInvalidLengthStake
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStake
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.DelegationAmount == nil {
+				m.DelegationAmount = &v11.Amount{}
+			}
+			if err := m.DelegationAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipStake(dAtA[iNdEx:])
@@ -6756,7 +8330,7 @@ func (m *BondingState) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ValidatorState) Unmarshal(dAtA []byte) error {
+func (m *Undelegate) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -6779,17 +8353,17 @@ func (m *ValidatorState) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ValidatorState: wiretype end group for non-group")
+			return fmt.Errorf("proto: Undelegate: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ValidatorState: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: Undelegate: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorIdentity", wireType)
 			}
-			m.State = 0
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -6799,64 +8373,50 @@ func (m *ValidatorState) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.State |= ValidatorState_ValidatorStateEnum(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-		default:
-			iNdEx = preIndex
-			skippy, err := skipStake(dAtA[iNdEx:])
-			if err != nil {
-				return err
+			if msglen < 0 {
+				return ErrInvalidLengthStake
 			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
 				return ErrInvalidLengthStake
 			}
-			if (iNdEx + skippy) > l {
+			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *ValidatorInfo) 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 ErrIntOverflowStake
+			if m.ValidatorIdentity == nil {
+				m.ValidatorIdentity = &v1.IdentityKey{}
 			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
+			if err := m.ValidatorIdentity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
 			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
+			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field StartEpochIndex", wireType)
 			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: ValidatorInfo: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ValidatorInfo: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
+			m.StartEpochIndex = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStake
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.StartEpochIndex |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Validator", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field UnbondedAmount", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -6883,16 +8443,16 @@ func (m *ValidatorInfo) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Validator == nil {
-				m.Validator = &Validator{}
+			if m.UnbondedAmount == nil {
+				m.UnbondedAmount = &v11.Amount{}
 			}
-			if err := m.Validator.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.UnbondedAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
-		case 2:
+		case 4:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field DelegationAmount", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -6919,16 +8479,16 @@ func (m *ValidatorInfo) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Status == nil {
-				m.Status = &ValidatorStatus{}
+			if m.DelegationAmount == nil {
+				m.DelegationAmount = &v11.Amount{}
 			}
-			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.DelegationAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
-		case 3:
+		case 5:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field RateData", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field FromEpoch", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -6955,10 +8515,10 @@ func (m *ValidatorInfo) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.RateData == nil {
-				m.RateData = &RateData{}
+			if m.FromEpoch == nil {
+				m.FromEpoch = &v12.Epoch{}
 			}
-			if err := m.RateData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.FromEpoch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -6983,7 +8543,7 @@ func (m *ValidatorInfo) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ValidatorDefinition) Unmarshal(dAtA []byte) error {
+func (m *UndelegateClaim) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -7006,15 +8566,15 @@ func (m *ValidatorDefinition) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ValidatorDefinition: wiretype end group for non-group")
+			return fmt.Errorf("proto: UndelegateClaim: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ValidatorDefinition: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: UndelegateClaim: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Validator", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -7041,16 +8601,16 @@ func (m *ValidatorDefinition) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Validator == nil {
-				m.Validator = &Validator{}
+			if m.Body == nil {
+				m.Body = &UndelegateClaimBody{}
 			}
-			if err := m.Validator.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field AuthSig", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType)
 			}
 			var byteLen int
 			for shift := uint(0); ; shift += 7 {
@@ -7077,9 +8637,9 @@ func (m *ValidatorDefinition) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.AuthSig = append(m.AuthSig[:0], dAtA[iNdEx:postIndex]...)
-			if m.AuthSig == nil {
-				m.AuthSig = []byte{}
+			m.Proof = append(m.Proof[:0], dAtA[iNdEx:postIndex]...)
+			if m.Proof == nil {
+				m.Proof = []byte{}
 			}
 			iNdEx = postIndex
 		default:
@@ -7103,7 +8663,7 @@ func (m *ValidatorDefinition) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *Delegate) Unmarshal(dAtA []byte) error {
+func (m *UndelegateClaimBody) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -7126,10 +8686,10 @@ func (m *Delegate) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: Delegate: wiretype end group for non-group")
+			return fmt.Errorf("proto: UndelegateClaimBody: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: Delegate: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: UndelegateClaimBody: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -7170,9 +8730,9 @@ func (m *Delegate) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		case 2:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field StartEpochIndex", wireType)
 			}
-			m.EpochIndex = 0
+			m.StartEpochIndex = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -7182,14 +8742,14 @@ func (m *Delegate) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.EpochIndex |= uint64(b&0x7F) << shift
+				m.StartEpochIndex |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
 		case 3:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field UnbondedAmount", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Penalty", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -7216,16 +8776,16 @@ func (m *Delegate) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.UnbondedAmount == nil {
-				m.UnbondedAmount = &v11.Amount{}
+			if m.Penalty == nil {
+				m.Penalty = &Penalty{}
 			}
-			if err := m.UnbondedAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.Penalty.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
 		case 4:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field DelegationAmount", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field BalanceCommitment", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -7252,13 +8812,32 @@ func (m *Delegate) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.DelegationAmount == nil {
-				m.DelegationAmount = &v11.Amount{}
+			if m.BalanceCommitment == nil {
+				m.BalanceCommitment = &v13.BalanceCommitment{}
 			}
-			if err := m.DelegationAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.BalanceCommitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
+		case 5:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field UnbondingStartHeight", wireType)
+			}
+			m.UnbondingStartHeight = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStake
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.UnbondingStartHeight |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipStake(dAtA[iNdEx:])
@@ -7280,7 +8859,7 @@ func (m *Delegate) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *Undelegate) Unmarshal(dAtA []byte) error {
+func (m *UndelegateClaimPlan) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -7303,15 +8882,70 @@ func (m *Undelegate) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: Undelegate: wiretype end group for non-group")
+			return fmt.Errorf("proto: UndelegateClaimPlan: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: Undelegate: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: UndelegateClaimPlan: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorIdentity", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorIdentity", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStake
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStake
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStake
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.ValidatorIdentity == nil {
+				m.ValidatorIdentity = &v1.IdentityKey{}
+			}
+			if err := m.ValidatorIdentity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field StartEpochIndex", wireType)
+			}
+			m.StartEpochIndex = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStake
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.StartEpochIndex |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Penalty", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -7338,18 +8972,18 @@ func (m *Undelegate) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.ValidatorIdentity == nil {
-				m.ValidatorIdentity = &v1.IdentityKey{}
+			if m.Penalty == nil {
+				m.Penalty = &Penalty{}
 			}
-			if err := m.ValidatorIdentity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.Penalty.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
-		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field StartEpochIndex", wireType)
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field UnbondingAmount", wireType)
 			}
-			m.StartEpochIndex = 0
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -7359,16 +8993,33 @@ func (m *Undelegate) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.StartEpochIndex |= uint64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-		case 3:
+			if msglen < 0 {
+				return ErrInvalidLengthStake
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStake
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.UnbondingAmount == nil {
+				m.UnbondingAmount = &v11.Amount{}
+			}
+			if err := m.UnbondingAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 6:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field UnbondedAmount", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field BalanceBlinding", wireType)
 			}
-			var msglen int
+			var byteLen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -7378,33 +9029,31 @@ func (m *Undelegate) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				byteLen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			if byteLen < 0 {
 				return ErrInvalidLengthStake
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + byteLen
 			if postIndex < 0 {
 				return ErrInvalidLengthStake
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.UnbondedAmount == nil {
-				m.UnbondedAmount = &v11.Amount{}
-			}
-			if err := m.UnbondedAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
+			m.BalanceBlinding = append(m.BalanceBlinding[:0], dAtA[iNdEx:postIndex]...)
+			if m.BalanceBlinding == nil {
+				m.BalanceBlinding = []byte{}
 			}
 			iNdEx = postIndex
-		case 4:
+		case 7:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field DelegationAmount", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ProofBlindingR", wireType)
 			}
-			var msglen int
+			var byteLen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -7414,33 +9063,31 @@ func (m *Undelegate) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				byteLen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			if byteLen < 0 {
 				return ErrInvalidLengthStake
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + byteLen
 			if postIndex < 0 {
 				return ErrInvalidLengthStake
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.DelegationAmount == nil {
-				m.DelegationAmount = &v11.Amount{}
-			}
-			if err := m.DelegationAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
+			m.ProofBlindingR = append(m.ProofBlindingR[:0], dAtA[iNdEx:postIndex]...)
+			if m.ProofBlindingR == nil {
+				m.ProofBlindingR = []byte{}
 			}
 			iNdEx = postIndex
-		case 5:
+		case 8:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field FromEpoch", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ProofBlindingS", wireType)
 			}
-			var msglen int
+			var byteLen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -7450,28 +9097,45 @@ func (m *Undelegate) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				byteLen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			if byteLen < 0 {
 				return ErrInvalidLengthStake
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + byteLen
 			if postIndex < 0 {
 				return ErrInvalidLengthStake
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.FromEpoch == nil {
-				m.FromEpoch = &v12.Epoch{}
-			}
-			if err := m.FromEpoch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
+			m.ProofBlindingS = append(m.ProofBlindingS[:0], dAtA[iNdEx:postIndex]...)
+			if m.ProofBlindingS == nil {
+				m.ProofBlindingS = []byte{}
 			}
 			iNdEx = postIndex
+		case 9:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field UnbondingStartHeight", wireType)
+			}
+			m.UnbondingStartHeight = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStake
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.UnbondingStartHeight |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipStake(dAtA[iNdEx:])
@@ -7493,7 +9157,7 @@ func (m *Undelegate) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *UndelegateClaim) Unmarshal(dAtA []byte) error {
+func (m *DelegationChanges) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -7516,15 +9180,15 @@ func (m *UndelegateClaim) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: UndelegateClaim: wiretype end group for non-group")
+			return fmt.Errorf("proto: DelegationChanges: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: UndelegateClaim: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: DelegationChanges: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Delegations", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -7551,18 +9215,16 @@ func (m *UndelegateClaim) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Body == nil {
-				m.Body = &UndelegateClaimBody{}
-			}
-			if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.Delegations = append(m.Delegations, &Delegate{})
+			if err := m.Delegations[len(m.Delegations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Undelegations", wireType)
 			}
-			var byteLen int
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -7572,24 +9234,24 @@ func (m *UndelegateClaim) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				byteLen |= int(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if byteLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthStake
 			}
-			postIndex := iNdEx + byteLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthStake
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Proof = append(m.Proof[:0], dAtA[iNdEx:postIndex]...)
-			if m.Proof == nil {
-				m.Proof = []byte{}
+			m.Undelegations = append(m.Undelegations, &Undelegate{})
+			if err := m.Undelegations[len(m.Undelegations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
 			}
 			iNdEx = postIndex
 		default:
@@ -7613,7 +9275,7 @@ func (m *UndelegateClaim) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *UndelegateClaimBody) Unmarshal(dAtA []byte) error {
+func (m *Uptime) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -7636,17 +9298,17 @@ func (m *UndelegateClaimBody) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: UndelegateClaimBody: wiretype end group for non-group")
+			return fmt.Errorf("proto: Uptime: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: UndelegateClaimBody: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: Uptime: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorIdentity", wireType)
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field AsOfBlockHeight", wireType)
 			}
-			var msglen int
+			m.AsOfBlockHeight = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -7656,33 +9318,16 @@ func (m *UndelegateClaimBody) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				m.AsOfBlockHeight |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
-				return ErrInvalidLengthStake
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthStake
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.ValidatorIdentity == nil {
-				m.ValidatorIdentity = &v1.IdentityKey{}
-			}
-			if err := m.ValidatorIdentity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
 		case 2:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field StartEpochIndex", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field WindowLen", wireType)
 			}
-			m.StartEpochIndex = 0
+			m.WindowLen = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -7692,16 +9337,16 @@ func (m *UndelegateClaimBody) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.StartEpochIndex |= uint64(b&0x7F) << shift
+				m.WindowLen |= uint32(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
 		case 3:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Penalty", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Bitvec", wireType)
 			}
-			var msglen int
+			var byteLen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -7711,31 +9356,79 @@ func (m *UndelegateClaimBody) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				byteLen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			if byteLen < 0 {
 				return ErrInvalidLengthStake
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + byteLen
 			if postIndex < 0 {
 				return ErrInvalidLengthStake
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Penalty == nil {
-				m.Penalty = &Penalty{}
+			m.Bitvec = append(m.Bitvec[:0], dAtA[iNdEx:postIndex]...)
+			if m.Bitvec == nil {
+				m.Bitvec = []byte{}
 			}
-			if err := m.Penalty.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStake(dAtA[iNdEx:])
+			if err != nil {
 				return err
 			}
-			iNdEx = postIndex
-		case 4:
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStake
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *CurrentConsensusKeys) 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 ErrIntOverflowStake
+			}
+			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: CurrentConsensusKeys: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: CurrentConsensusKeys: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field BalanceCommitment", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ConsensusKeys", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -7762,32 +9455,11 @@ func (m *UndelegateClaimBody) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.BalanceCommitment == nil {
-				m.BalanceCommitment = &v13.BalanceCommitment{}
-			}
-			if err := m.BalanceCommitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.ConsensusKeys = append(m.ConsensusKeys, &v1.ConsensusKey{})
+			if err := m.ConsensusKeys[len(m.ConsensusKeys)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
-		case 5:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field UnbondingStartHeight", wireType)
-			}
-			m.UnbondingStartHeight = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStake
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.UnbondingStartHeight |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipStake(dAtA[iNdEx:])
@@ -7809,7 +9481,7 @@ func (m *UndelegateClaimBody) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *UndelegateClaimPlan) Unmarshal(dAtA []byte) error {
+func (m *Penalty) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -7832,17 +9504,17 @@ func (m *UndelegateClaimPlan) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: UndelegateClaimPlan: wiretype end group for non-group")
+			return fmt.Errorf("proto: Penalty: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: UndelegateClaimPlan: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: Penalty: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorIdentity", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType)
 			}
-			var msglen int
+			var byteLen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -7852,86 +9524,79 @@ func (m *UndelegateClaimPlan) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				byteLen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			if byteLen < 0 {
 				return ErrInvalidLengthStake
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + byteLen
 			if postIndex < 0 {
 				return ErrInvalidLengthStake
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.ValidatorIdentity == nil {
-				m.ValidatorIdentity = &v1.IdentityKey{}
-			}
-			if err := m.ValidatorIdentity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
+			m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...)
+			if m.Inner == nil {
+				m.Inner = []byte{}
 			}
 			iNdEx = postIndex
-		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field StartEpochIndex", wireType)
-			}
-			m.StartEpochIndex = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStake
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.StartEpochIndex |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 4:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Penalty", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStake
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthStake
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStake(dAtA[iNdEx:])
+			if err != nil {
+				return err
 			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
 				return ErrInvalidLengthStake
 			}
-			if postIndex > l {
+			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Penalty == nil {
-				m.Penalty = &Penalty{}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *GetValidatorInfoRequest) 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 ErrIntOverflowStake
 			}
-			if err := m.Penalty.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
 			}
-			iNdEx = postIndex
-		case 5:
+			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: GetValidatorInfoRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: GetValidatorInfoRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field UnbondingAmount", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -7958,86 +9623,68 @@ func (m *UndelegateClaimPlan) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.UnbondingAmount == nil {
-				m.UnbondingAmount = &v11.Amount{}
+			if m.IdentityKey == nil {
+				m.IdentityKey = &v1.IdentityKey{}
 			}
-			if err := m.UnbondingAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
-		case 6:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field BalanceBlinding", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStake
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthStake
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStake(dAtA[iNdEx:])
+			if err != nil {
+				return err
 			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
 				return ErrInvalidLengthStake
 			}
-			if postIndex > l {
+			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.BalanceBlinding = append(m.BalanceBlinding[:0], dAtA[iNdEx:postIndex]...)
-			if m.BalanceBlinding == nil {
-				m.BalanceBlinding = []byte{}
-			}
-			iNdEx = postIndex
-		case 7:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ProofBlindingR", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStake
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthStake
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthStake
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *GetValidatorInfoResponse) 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 ErrIntOverflowStake
 			}
-			if postIndex > l {
+			if iNdEx >= l {
 				return io.ErrUnexpectedEOF
 			}
-			m.ProofBlindingR = append(m.ProofBlindingR[:0], dAtA[iNdEx:postIndex]...)
-			if m.ProofBlindingR == nil {
-				m.ProofBlindingR = []byte{}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
 			}
-			iNdEx = postIndex
-		case 8:
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: GetValidatorInfoResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: GetValidatorInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ProofBlindingS", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorInfo", wireType)
 			}
-			var byteLen int
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -8047,45 +9694,28 @@ func (m *UndelegateClaimPlan) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				byteLen |= int(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if byteLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthStake
 			}
-			postIndex := iNdEx + byteLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthStake
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.ProofBlindingS = append(m.ProofBlindingS[:0], dAtA[iNdEx:postIndex]...)
-			if m.ProofBlindingS == nil {
-				m.ProofBlindingS = []byte{}
-			}
-			iNdEx = postIndex
-		case 9:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field UnbondingStartHeight", wireType)
+			if m.ValidatorInfo == nil {
+				m.ValidatorInfo = &ValidatorInfo{}
 			}
-			m.UnbondingStartHeight = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStake
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.UnbondingStartHeight |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
+			if err := m.ValidatorInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
 			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipStake(dAtA[iNdEx:])
@@ -8107,7 +9737,7 @@ func (m *UndelegateClaimPlan) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *DelegationChanges) Unmarshal(dAtA []byte) error {
+func (m *ValidatorInfoRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -8130,17 +9760,17 @@ func (m *DelegationChanges) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: DelegationChanges: wiretype end group for non-group")
+			return fmt.Errorf("proto: ValidatorInfoRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: DelegationChanges: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: ValidatorInfoRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Delegations", wireType)
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ShowInactive", wireType)
 			}
-			var msglen int
+			var v int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -8150,29 +9780,65 @@ func (m *DelegationChanges) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				v |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
-				return ErrInvalidLengthStake
+			m.ShowInactive = bool(v != 0)
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStake(dAtA[iNdEx:])
+			if err != nil {
+				return err
 			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
 				return ErrInvalidLengthStake
 			}
-			if postIndex > l {
+			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Delegations = append(m.Delegations, &Delegate{})
-			if err := m.Delegations[len(m.Delegations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *ValidatorInfoResponse) 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 ErrIntOverflowStake
 			}
-			iNdEx = postIndex
-		case 2:
+			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: ValidatorInfoResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ValidatorInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Undelegations", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorInfo", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -8199,8 +9865,10 @@ func (m *DelegationChanges) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Undelegations = append(m.Undelegations, &Undelegate{})
-			if err := m.Undelegations[len(m.Undelegations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if m.ValidatorInfo == nil {
+				m.ValidatorInfo = &ValidatorInfo{}
+			}
+			if err := m.ValidatorInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -8225,7 +9893,7 @@ func (m *DelegationChanges) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *Uptime) Unmarshal(dAtA []byte) error {
+func (m *ValidatorStatusRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -8248,55 +9916,17 @@ func (m *Uptime) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: Uptime: wiretype end group for non-group")
+			return fmt.Errorf("proto: ValidatorStatusRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: Uptime: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: ValidatorStatusRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
-		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field AsOfBlockHeight", wireType)
-			}
-			m.AsOfBlockHeight = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStake
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.AsOfBlockHeight |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
 		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field WindowLen", wireType)
-			}
-			m.WindowLen = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStake
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.WindowLen |= uint32(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 3:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Bitvec", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType)
 			}
-			var byteLen int
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -8306,24 +9936,26 @@ func (m *Uptime) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				byteLen |= int(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if byteLen < 0 {
+			if msglen < 0 {
 				return ErrInvalidLengthStake
 			}
-			postIndex := iNdEx + byteLen
+			postIndex := iNdEx + msglen
 			if postIndex < 0 {
 				return ErrInvalidLengthStake
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Bitvec = append(m.Bitvec[:0], dAtA[iNdEx:postIndex]...)
-			if m.Bitvec == nil {
-				m.Bitvec = []byte{}
+			if m.IdentityKey == nil {
+				m.IdentityKey = &v1.IdentityKey{}
+			}
+			if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
 			}
 			iNdEx = postIndex
 		default:
@@ -8347,7 +9979,7 @@ func (m *Uptime) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *CurrentConsensusKeys) Unmarshal(dAtA []byte) error {
+func (m *ValidatorStatusResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -8370,15 +10002,15 @@ func (m *CurrentConsensusKeys) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: CurrentConsensusKeys: wiretype end group for non-group")
+			return fmt.Errorf("proto: ValidatorStatusResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: CurrentConsensusKeys: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: ValidatorStatusResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ConsensusKeys", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -8405,8 +10037,10 @@ func (m *CurrentConsensusKeys) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.ConsensusKeys = append(m.ConsensusKeys, &v1.ConsensusKey{})
-			if err := m.ConsensusKeys[len(m.ConsensusKeys)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if m.Status == nil {
+				m.Status = &ValidatorStatus{}
+			}
+			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -8431,7 +10065,7 @@ func (m *CurrentConsensusKeys) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *Penalty) Unmarshal(dAtA []byte) error {
+func (m *ValidatorPenaltyRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -8454,17 +10088,72 @@ func (m *Penalty) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: Penalty: wiretype end group for non-group")
+			return fmt.Errorf("proto: ValidatorPenaltyRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: Penalty: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: ValidatorPenaltyRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
-		case 1:
+		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStake
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStake
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStake
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.IdentityKey == nil {
+				m.IdentityKey = &v1.IdentityKey{}
+			}
+			if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field StartEpochIndex", wireType)
+			}
+			m.StartEpochIndex = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStake
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.StartEpochIndex |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field EndEpochIndex", wireType)
 			}
-			var byteLen int
+			m.EndEpochIndex = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -8474,26 +10163,11 @@ func (m *Penalty) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				byteLen |= int(b&0x7F) << shift
+				m.EndEpochIndex |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if byteLen < 0 {
-				return ErrInvalidLengthStake
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthStake
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...)
-			if m.Inner == nil {
-				m.Inner = []byte{}
-			}
-			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipStake(dAtA[iNdEx:])
@@ -8515,7 +10189,7 @@ func (m *Penalty) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *GetValidatorInfoRequest) Unmarshal(dAtA []byte) error {
+func (m *ValidatorPenaltyResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -8538,15 +10212,15 @@ func (m *GetValidatorInfoRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: GetValidatorInfoRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: ValidatorPenaltyResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: GetValidatorInfoRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: ValidatorPenaltyResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
-		case 2:
+		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Penalty", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -8573,10 +10247,10 @@ func (m *GetValidatorInfoRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.IdentityKey == nil {
-				m.IdentityKey = &v1.IdentityKey{}
+			if m.Penalty == nil {
+				m.Penalty = &Penalty{}
 			}
-			if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.Penalty.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -8601,7 +10275,7 @@ func (m *GetValidatorInfoRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *GetValidatorInfoResponse) Unmarshal(dAtA []byte) error {
+func (m *CurrentValidatorRateRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -8624,15 +10298,15 @@ func (m *GetValidatorInfoResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: GetValidatorInfoResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: CurrentValidatorRateRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: GetValidatorInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: CurrentValidatorRateRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
-		case 1:
+		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorInfo", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -8659,10 +10333,10 @@ func (m *GetValidatorInfoResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.ValidatorInfo == nil {
-				m.ValidatorInfo = &ValidatorInfo{}
+			if m.IdentityKey == nil {
+				m.IdentityKey = &v1.IdentityKey{}
 			}
-			if err := m.ValidatorInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -8687,7 +10361,7 @@ func (m *GetValidatorInfoResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ValidatorInfoRequest) Unmarshal(dAtA []byte) error {
+func (m *CurrentValidatorRateResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -8710,17 +10384,17 @@ func (m *ValidatorInfoRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ValidatorInfoRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: CurrentValidatorRateResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ValidatorInfoRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: CurrentValidatorRateResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
-		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ShowInactive", wireType)
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
 			}
-			var v int
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -8730,12 +10404,28 @@ func (m *ValidatorInfoRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				v |= int(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			m.ShowInactive = bool(v != 0)
+			if msglen < 0 {
+				return ErrInvalidLengthStake
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStake
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Data == nil {
+				m.Data = &RateData{}
+			}
+			if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipStake(dAtA[iNdEx:])
@@ -8757,7 +10447,7 @@ func (m *ValidatorInfoRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ValidatorInfoResponse) Unmarshal(dAtA []byte) error {
+func (m *ValidatorUptimeRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -8780,15 +10470,15 @@ func (m *ValidatorInfoResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ValidatorInfoResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: ValidatorUptimeRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ValidatorInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: ValidatorUptimeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
-		case 1:
+		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorInfo", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -8815,10 +10505,10 @@ func (m *ValidatorInfoResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.ValidatorInfo == nil {
-				m.ValidatorInfo = &ValidatorInfo{}
+			if m.IdentityKey == nil {
+				m.IdentityKey = &v1.IdentityKey{}
 			}
-			if err := m.ValidatorInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -8843,7 +10533,7 @@ func (m *ValidatorInfoResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ValidatorStatusRequest) Unmarshal(dAtA []byte) error {
+func (m *ValidatorUptimeResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -8866,15 +10556,15 @@ func (m *ValidatorStatusRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ValidatorStatusRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: ValidatorUptimeResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ValidatorStatusRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: ValidatorUptimeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
-		case 2:
+		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Uptime", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -8901,10 +10591,10 @@ func (m *ValidatorStatusRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.IdentityKey == nil {
-				m.IdentityKey = &v1.IdentityKey{}
+			if m.Uptime == nil {
+				m.Uptime = &Uptime{}
 			}
-			if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.Uptime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -8929,7 +10619,7 @@ func (m *ValidatorStatusRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ValidatorStatusResponse) Unmarshal(dAtA []byte) error {
+func (m *StakeParameters) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -8952,15 +10642,148 @@ func (m *ValidatorStatusResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ValidatorStatusResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: StakeParameters: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ValidatorStatusResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: StakeParameters: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field UnbondingEpochs", wireType)
+			}
+			m.UnbondingEpochs = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStake
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.UnbondingEpochs |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ActiveValidatorLimit", wireType)
+			}
+			m.ActiveValidatorLimit = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStake
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ActiveValidatorLimit |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field BaseRewardRate", wireType)
+			}
+			m.BaseRewardRate = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStake
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.BaseRewardRate |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SlashingPenaltyMisbehavior", wireType)
+			}
+			m.SlashingPenaltyMisbehavior = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStake
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.SlashingPenaltyMisbehavior |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 5:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SlashingPenaltyDowntime", wireType)
+			}
+			m.SlashingPenaltyDowntime = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStake
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.SlashingPenaltyDowntime |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 6:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SignedBlocksWindowLen", wireType)
+			}
+			m.SignedBlocksWindowLen = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStake
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.SignedBlocksWindowLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 7:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MissedBlocksMaximum", wireType)
+			}
+			m.MissedBlocksMaximum = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStake
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.MissedBlocksMaximum |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 8:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field MinValidatorStake", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -8987,13 +10810,32 @@ func (m *ValidatorStatusResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Status == nil {
-				m.Status = &ValidatorStatus{}
+			if m.MinValidatorStake == nil {
+				m.MinValidatorStake = &v11.Amount{}
 			}
-			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.MinValidatorStake.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
+		case 9:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field UnbondingDelay", wireType)
+			}
+			m.UnbondingDelay = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStake
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.UnbondingDelay |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipStake(dAtA[iNdEx:])
@@ -9015,7 +10857,7 @@ func (m *ValidatorStatusResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ValidatorPenaltyRequest) Unmarshal(dAtA []byte) error {
+func (m *GenesisContent) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -9038,15 +10880,15 @@ func (m *ValidatorPenaltyRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ValidatorPenaltyRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: GenesisContent: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ValidatorPenaltyRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: GenesisContent: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
-		case 2:
+		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field StakeParams", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -9073,18 +10915,18 @@ func (m *ValidatorPenaltyRequest) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.IdentityKey == nil {
-				m.IdentityKey = &v1.IdentityKey{}
+			if m.StakeParams == nil {
+				m.StakeParams = &StakeParameters{}
 			}
-			if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.StakeParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
-		case 3:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field StartEpochIndex", wireType)
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Validators", wireType)
 			}
-			m.StartEpochIndex = 0
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -9094,30 +10936,26 @@ func (m *ValidatorPenaltyRequest) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.StartEpochIndex |= uint64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-		case 4:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field EndEpochIndex", wireType)
+			if msglen < 0 {
+				return ErrInvalidLengthStake
 			}
-			m.EndEpochIndex = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStake
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.EndEpochIndex |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStake
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Validators = append(m.Validators, &Validator{})
+			if err := m.Validators[len(m.Validators)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
 			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipStake(dAtA[iNdEx:])
@@ -9139,7 +10977,7 @@ func (m *ValidatorPenaltyRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ValidatorPenaltyResponse) Unmarshal(dAtA []byte) error {
+func (m *EventTombstoneValidator) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -9162,15 +11000,53 @@ func (m *ValidatorPenaltyResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ValidatorPenaltyResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: EventTombstoneValidator: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ValidatorPenaltyResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: EventTombstoneValidator: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field EvidenceHeight", wireType)
+			}
+			m.EvidenceHeight = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStake
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.EvidenceHeight |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CurrentHeight", wireType)
+			}
+			m.CurrentHeight = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStake
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.CurrentHeight |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 4:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Penalty", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -9197,13 +11073,66 @@ func (m *ValidatorPenaltyResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Penalty == nil {
-				m.Penalty = &Penalty{}
+			if m.IdentityKey == nil {
+				m.IdentityKey = &v1.IdentityKey{}
 			}
-			if err := m.Penalty.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStake
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthStake
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthStake
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Address = append(m.Address[:0], dAtA[iNdEx:postIndex]...)
+			if m.Address == nil {
+				m.Address = []byte{}
+			}
+			iNdEx = postIndex
+		case 6:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field VotingPower", wireType)
+			}
+			m.VotingPower = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStake
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.VotingPower |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipStake(dAtA[iNdEx:])
@@ -9225,7 +11154,7 @@ func (m *ValidatorPenaltyResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *CurrentValidatorRateRequest) Unmarshal(dAtA []byte) error {
+func (m *EventValidatorStateChange) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -9248,13 +11177,13 @@ func (m *CurrentValidatorRateRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: CurrentValidatorRateRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: EventValidatorStateChange: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: CurrentValidatorRateRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: EventValidatorStateChange: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
-		case 2:
+		case 1:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType)
 			}
@@ -9290,59 +11219,9 @@ func (m *CurrentValidatorRateRequest) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipStake(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthStake
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *CurrentValidatorRateResponse) 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 ErrIntOverflowStake
-			}
-			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: CurrentValidatorRateResponse: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: CurrentValidatorRateResponse: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
+		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -9369,10 +11248,10 @@ func (m *CurrentValidatorRateResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Data == nil {
-				m.Data = &RateData{}
+			if m.State == nil {
+				m.State = &ValidatorState{}
 			}
-			if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.State.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -9397,7 +11276,7 @@ func (m *CurrentValidatorRateResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ValidatorUptimeRequest) Unmarshal(dAtA []byte) error {
+func (m *EventValidatorVotingPowerChange) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -9420,13 +11299,13 @@ func (m *ValidatorUptimeRequest) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ValidatorUptimeRequest: wiretype end group for non-group")
+			return fmt.Errorf("proto: EventValidatorVotingPowerChange: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ValidatorUptimeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: EventValidatorVotingPowerChange: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
-		case 2:
+		case 1:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType)
 			}
@@ -9462,6 +11341,42 @@ func (m *ValidatorUptimeRequest) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field VotingPower", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStake
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStake
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStake
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.VotingPower == nil {
+				m.VotingPower = &v11.Amount{}
+			}
+			if err := m.VotingPower.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipStake(dAtA[iNdEx:])
@@ -9483,7 +11398,7 @@ func (m *ValidatorUptimeRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ValidatorUptimeResponse) Unmarshal(dAtA []byte) error {
+func (m *EventValidatorBondingStateChange) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -9506,15 +11421,15 @@ func (m *ValidatorUptimeResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ValidatorUptimeResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: EventValidatorBondingStateChange: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ValidatorUptimeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: EventValidatorBondingStateChange: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Uptime", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -9541,10 +11456,46 @@ func (m *ValidatorUptimeResponse) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.Uptime == nil {
-				m.Uptime = &Uptime{}
+			if m.IdentityKey == nil {
+				m.IdentityKey = &v1.IdentityKey{}
 			}
-			if err := m.Uptime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field BondingState", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowStake
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthStake
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStake
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.BondingState == nil {
+				m.BondingState = &BondingState{}
+			}
+			if err := m.BondingState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -9569,7 +11520,7 @@ func (m *ValidatorUptimeResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *StakeParameters) Unmarshal(dAtA []byte) error {
+func (m *EventRateDataChange) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -9592,17 +11543,17 @@ func (m *StakeParameters) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: StakeParameters: wiretype end group for non-group")
+			return fmt.Errorf("proto: EventRateDataChange: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: StakeParameters: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: EventRateDataChange: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field UnbondingEpochs", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType)
 			}
-			m.UnbondingEpochs = 0
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -9612,16 +11563,33 @@ func (m *StakeParameters) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.UnbondingEpochs |= uint64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
+			if msglen < 0 {
+				return ErrInvalidLengthStake
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStake
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.IdentityKey == nil {
+				m.IdentityKey = &v1.IdentityKey{}
+			}
+			if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ActiveValidatorLimit", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RateData", wireType)
 			}
-			m.ActiveValidatorLimit = 0
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -9631,109 +11599,81 @@ func (m *StakeParameters) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.ActiveValidatorLimit |= uint64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-		case 3:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field BaseRewardRate", wireType)
+			if msglen < 0 {
+				return ErrInvalidLengthStake
 			}
-			m.BaseRewardRate = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStake
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.BaseRewardRate |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStake
 			}
-		case 4:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field SlashingPenaltyMisbehavior", wireType)
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
 			}
-			m.SlashingPenaltyMisbehavior = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStake
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.SlashingPenaltyMisbehavior |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
+			if m.RateData == nil {
+				m.RateData = &RateData{}
 			}
-		case 5:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field SlashingPenaltyDowntime", wireType)
+			if err := m.RateData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
 			}
-			m.SlashingPenaltyDowntime = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStake
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.SlashingPenaltyDowntime |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStake(dAtA[iNdEx:])
+			if err != nil {
+				return err
 			}
-		case 6:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field SignedBlocksWindowLen", wireType)
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStake
 			}
-			m.SignedBlocksWindowLen = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStake
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.SignedBlocksWindowLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
 			}
-		case 7:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MissedBlocksMaximum", wireType)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *EventValidatorDefinitionUpload) 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 ErrIntOverflowStake
 			}
-			m.MissedBlocksMaximum = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowStake
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.MissedBlocksMaximum |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
 			}
-		case 8:
+			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: EventValidatorDefinitionUpload: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: EventValidatorDefinitionUpload: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MinValidatorStake", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Validator", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -9760,18 +11700,68 @@ func (m *StakeParameters) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.MinValidatorStake == nil {
-				m.MinValidatorStake = &v11.Amount{}
+			if m.Validator == nil {
+				m.Validator = &Validator{}
 			}
-			if err := m.MinValidatorStake.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.Validator.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
-		case 9:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field UnbondingDelay", wireType)
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStake(dAtA[iNdEx:])
+			if err != nil {
+				return err
 			}
-			m.UnbondingDelay = 0
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStake
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *EventValidatorMissedBlock) 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 ErrIntOverflowStake
+			}
+			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: EventValidatorMissedBlock: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: EventValidatorMissedBlock: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType)
+			}
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -9781,11 +11771,28 @@ func (m *StakeParameters) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.UnbondingDelay |= uint64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
+			if msglen < 0 {
+				return ErrInvalidLengthStake
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStake
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.IdentityKey == nil {
+				m.IdentityKey = &v1.IdentityKey{}
+			}
+			if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipStake(dAtA[iNdEx:])
@@ -9807,7 +11814,7 @@ func (m *StakeParameters) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *GenesisContent) Unmarshal(dAtA []byte) error {
+func (m *EventDelegate) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -9830,15 +11837,15 @@ func (m *GenesisContent) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: GenesisContent: wiretype end group for non-group")
+			return fmt.Errorf("proto: EventDelegate: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: GenesisContent: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: EventDelegate: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field StakeParams", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -9865,16 +11872,16 @@ func (m *GenesisContent) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if m.StakeParams == nil {
-				m.StakeParams = &StakeParameters{}
+			if m.IdentityKey == nil {
+				m.IdentityKey = &v1.IdentityKey{}
 			}
-			if err := m.StakeParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
-		case 2:
+		case 3:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Validators", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -9901,8 +11908,10 @@ func (m *GenesisContent) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Validators = append(m.Validators, &Validator{})
-			if err := m.Validators[len(m.Validators)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if m.Amount == nil {
+				m.Amount = &v11.Amount{}
+			}
+			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -9927,7 +11936,7 @@ func (m *GenesisContent) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *EventTombstoneValidator) Unmarshal(dAtA []byte) error {
+func (m *EventUndelegate) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -9950,17 +11959,17 @@ func (m *EventTombstoneValidator) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: EventTombstoneValidator: wiretype end group for non-group")
+			return fmt.Errorf("proto: EventUndelegate: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: EventTombstoneValidator: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: EventUndelegate: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field EvidenceHeight", wireType)
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType)
 			}
-			m.EvidenceHeight = 0
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -9970,16 +11979,33 @@ func (m *EventTombstoneValidator) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.EvidenceHeight |= uint64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field CurrentHeight", wireType)
+			if msglen < 0 {
+				return ErrInvalidLengthStake
 			}
-			m.CurrentHeight = 0
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStake
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.IdentityKey == nil {
+				m.IdentityKey = &v1.IdentityKey{}
+			}
+			if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
+			}
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -9989,12 +12015,79 @@ func (m *EventTombstoneValidator) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.CurrentHeight |= uint64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-		case 4:
+			if msglen < 0 {
+				return ErrInvalidLengthStake
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStake
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Amount == nil {
+				m.Amount = &v11.Amount{}
+			}
+			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipStake(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthStake
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *EventSlashingPenaltyApplied) 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 ErrIntOverflowStake
+			}
+			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: EventSlashingPenaltyApplied: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: EventSlashingPenaltyApplied: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType)
 			}
@@ -10030,11 +12123,11 @@ func (m *EventTombstoneValidator) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
-		case 5:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
 			}
-			var byteLen int
+			m.EpochIndex = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -10044,31 +12137,16 @@ func (m *EventTombstoneValidator) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				byteLen |= int(b&0x7F) << shift
+				m.EpochIndex |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if byteLen < 0 {
-				return ErrInvalidLengthStake
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthStake
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Address = append(m.Address[:0], dAtA[iNdEx:postIndex]...)
-			if m.Address == nil {
-				m.Address = []byte{}
-			}
-			iNdEx = postIndex
-		case 6:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field VotingPower", wireType)
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field NewPenalty", wireType)
 			}
-			m.VotingPower = 0
+			var msglen int
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowStake
@@ -10078,11 +12156,28 @@ func (m *EventTombstoneValidator) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.VotingPower |= uint64(b&0x7F) << shift
+				msglen |= int(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
+			if msglen < 0 {
+				return ErrInvalidLengthStake
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthStake
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.NewPenalty == nil {
+				m.NewPenalty = &Penalty{}
+			}
+			if err := m.NewPenalty.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipStake(dAtA[iNdEx:])
diff --git a/relayer/chains/penumbra/view/v1/view.pb.go b/relayer/chains/penumbra/view/v1/view.pb.go
index 720d2e7a9..e5d6e065f 100644
--- a/relayer/chains/penumbra/view/v1/view.pb.go
+++ b/relayer/chains/penumbra/view/v1/view.pb.go
@@ -763,6 +763,7 @@ type TransactionPlannerRequest struct {
 	Source *v1.AddressIndex `protobuf:"bytes,4,opt,name=source,proto3" json:"source,omitempty"`
 	// Request contents
 	Outputs                     []*TransactionPlannerRequest_Output                     `protobuf:"bytes,20,rep,name=outputs,proto3" json:"outputs,omitempty"`
+	Spends                      []*TransactionPlannerRequest_Spend                      `protobuf:"bytes,21,rep,name=spends,proto3" json:"spends,omitempty"`
 	Swaps                       []*TransactionPlannerRequest_Swap                       `protobuf:"bytes,30,rep,name=swaps,proto3" json:"swaps,omitempty"`
 	SwapClaims                  []*TransactionPlannerRequest_SwapClaim                  `protobuf:"bytes,31,rep,name=swap_claims,json=swapClaims,proto3" json:"swap_claims,omitempty"`
 	Delegations                 []*TransactionPlannerRequest_Delegate                   `protobuf:"bytes,40,rep,name=delegations,proto3" json:"delegations,omitempty"`
@@ -872,6 +873,13 @@ func (m *TransactionPlannerRequest) GetOutputs() []*TransactionPlannerRequest_Ou
 	return nil
 }
 
+func (m *TransactionPlannerRequest) GetSpends() []*TransactionPlannerRequest_Spend {
+	if m != nil {
+		return m.Spends
+	}
+	return nil
+}
+
 func (m *TransactionPlannerRequest) GetSwaps() []*TransactionPlannerRequest_Swap {
 	if m != nil {
 		return m.Swaps
@@ -1055,6 +1063,60 @@ func (m *TransactionPlannerRequest_Output) GetAddress() *v1.Address {
 	return nil
 }
 
+type TransactionPlannerRequest_Spend struct {
+	// The input amount and denomination in which the Spend is issued.
+	Value *v18.Value `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
+	// The source address from which the Spend will be sent.
+	Address *v1.Address `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
+}
+
+func (m *TransactionPlannerRequest_Spend) Reset()         { *m = TransactionPlannerRequest_Spend{} }
+func (m *TransactionPlannerRequest_Spend) String() string { return proto.CompactTextString(m) }
+func (*TransactionPlannerRequest_Spend) ProtoMessage()    {}
+func (*TransactionPlannerRequest_Spend) Descriptor() ([]byte, []int) {
+	return fileDescriptor_dba93d04e42ddfc3, []int{6, 1}
+}
+func (m *TransactionPlannerRequest_Spend) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *TransactionPlannerRequest_Spend) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_TransactionPlannerRequest_Spend.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 *TransactionPlannerRequest_Spend) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_TransactionPlannerRequest_Spend.Merge(m, src)
+}
+func (m *TransactionPlannerRequest_Spend) XXX_Size() int {
+	return m.Size()
+}
+func (m *TransactionPlannerRequest_Spend) XXX_DiscardUnknown() {
+	xxx_messageInfo_TransactionPlannerRequest_Spend.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_TransactionPlannerRequest_Spend proto.InternalMessageInfo
+
+func (m *TransactionPlannerRequest_Spend) GetValue() *v18.Value {
+	if m != nil {
+		return m.Value
+	}
+	return nil
+}
+
+func (m *TransactionPlannerRequest_Spend) GetAddress() *v1.Address {
+	if m != nil {
+		return m.Address
+	}
+	return nil
+}
+
 type TransactionPlannerRequest_Swap struct {
 	// The input amount and denomination to be traded in the Swap.
 	Value *v18.Value `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
@@ -1070,7 +1132,7 @@ func (m *TransactionPlannerRequest_Swap) Reset()         { *m = TransactionPlann
 func (m *TransactionPlannerRequest_Swap) String() string { return proto.CompactTextString(m) }
 func (*TransactionPlannerRequest_Swap) ProtoMessage()    {}
 func (*TransactionPlannerRequest_Swap) Descriptor() ([]byte, []int) {
-	return fileDescriptor_dba93d04e42ddfc3, []int{6, 1}
+	return fileDescriptor_dba93d04e42ddfc3, []int{6, 2}
 }
 func (m *TransactionPlannerRequest_Swap) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1138,7 +1200,7 @@ func (m *TransactionPlannerRequest_SwapClaim) Reset()         { *m = Transaction
 func (m *TransactionPlannerRequest_SwapClaim) String() string { return proto.CompactTextString(m) }
 func (*TransactionPlannerRequest_SwapClaim) ProtoMessage()    {}
 func (*TransactionPlannerRequest_SwapClaim) Descriptor() ([]byte, []int) {
-	return fileDescriptor_dba93d04e42ddfc3, []int{6, 2}
+	return fileDescriptor_dba93d04e42ddfc3, []int{6, 3}
 }
 func (m *TransactionPlannerRequest_SwapClaim) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1183,7 +1245,7 @@ func (m *TransactionPlannerRequest_Delegate) Reset()         { *m = TransactionP
 func (m *TransactionPlannerRequest_Delegate) String() string { return proto.CompactTextString(m) }
 func (*TransactionPlannerRequest_Delegate) ProtoMessage()    {}
 func (*TransactionPlannerRequest_Delegate) Descriptor() ([]byte, []int) {
-	return fileDescriptor_dba93d04e42ddfc3, []int{6, 3}
+	return fileDescriptor_dba93d04e42ddfc3, []int{6, 4}
 }
 func (m *TransactionPlannerRequest_Delegate) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1235,7 +1297,7 @@ func (m *TransactionPlannerRequest_Undelegate) Reset()         { *m = Transactio
 func (m *TransactionPlannerRequest_Undelegate) String() string { return proto.CompactTextString(m) }
 func (*TransactionPlannerRequest_Undelegate) ProtoMessage()    {}
 func (*TransactionPlannerRequest_Undelegate) Descriptor() ([]byte, []int) {
-	return fileDescriptor_dba93d04e42ddfc3, []int{6, 4}
+	return fileDescriptor_dba93d04e42ddfc3, []int{6, 5}
 }
 func (m *TransactionPlannerRequest_Undelegate) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1301,7 +1363,7 @@ func (m *TransactionPlannerRequest_UndelegateClaim) String() string {
 }
 func (*TransactionPlannerRequest_UndelegateClaim) ProtoMessage() {}
 func (*TransactionPlannerRequest_UndelegateClaim) Descriptor() ([]byte, []int) {
-	return fileDescriptor_dba93d04e42ddfc3, []int{6, 5}
+	return fileDescriptor_dba93d04e42ddfc3, []int{6, 6}
 }
 func (m *TransactionPlannerRequest_UndelegateClaim) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1380,7 +1442,7 @@ func (m *TransactionPlannerRequest_PositionOpen) Reset() {
 func (m *TransactionPlannerRequest_PositionOpen) String() string { return proto.CompactTextString(m) }
 func (*TransactionPlannerRequest_PositionOpen) ProtoMessage()    {}
 func (*TransactionPlannerRequest_PositionOpen) Descriptor() ([]byte, []int) {
-	return fileDescriptor_dba93d04e42ddfc3, []int{6, 6}
+	return fileDescriptor_dba93d04e42ddfc3, []int{6, 7}
 }
 func (m *TransactionPlannerRequest_PositionOpen) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1427,7 +1489,7 @@ func (m *TransactionPlannerRequest_PositionClose) Reset() {
 func (m *TransactionPlannerRequest_PositionClose) String() string { return proto.CompactTextString(m) }
 func (*TransactionPlannerRequest_PositionClose) ProtoMessage()    {}
 func (*TransactionPlannerRequest_PositionClose) Descriptor() ([]byte, []int) {
-	return fileDescriptor_dba93d04e42ddfc3, []int{6, 7}
+	return fileDescriptor_dba93d04e42ddfc3, []int{6, 8}
 }
 func (m *TransactionPlannerRequest_PositionClose) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1480,7 +1542,7 @@ func (m *TransactionPlannerRequest_PositionWithdraw) String() string {
 }
 func (*TransactionPlannerRequest_PositionWithdraw) ProtoMessage() {}
 func (*TransactionPlannerRequest_PositionWithdraw) Descriptor() ([]byte, []int) {
-	return fileDescriptor_dba93d04e42ddfc3, []int{6, 8}
+	return fileDescriptor_dba93d04e42ddfc3, []int{6, 9}
 }
 func (m *TransactionPlannerRequest_PositionWithdraw) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1543,7 +1605,7 @@ func (m *TransactionPlannerRequest_ActionDutchAuctionSchedule) String() string {
 }
 func (*TransactionPlannerRequest_ActionDutchAuctionSchedule) ProtoMessage() {}
 func (*TransactionPlannerRequest_ActionDutchAuctionSchedule) Descriptor() ([]byte, []int) {
-	return fileDescriptor_dba93d04e42ddfc3, []int{6, 9}
+	return fileDescriptor_dba93d04e42ddfc3, []int{6, 10}
 }
 func (m *TransactionPlannerRequest_ActionDutchAuctionSchedule) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1592,7 +1654,7 @@ func (m *TransactionPlannerRequest_ActionDutchAuctionEnd) String() string {
 }
 func (*TransactionPlannerRequest_ActionDutchAuctionEnd) ProtoMessage() {}
 func (*TransactionPlannerRequest_ActionDutchAuctionEnd) Descriptor() ([]byte, []int) {
-	return fileDescriptor_dba93d04e42ddfc3, []int{6, 10}
+	return fileDescriptor_dba93d04e42ddfc3, []int{6, 11}
 }
 func (m *TransactionPlannerRequest_ActionDutchAuctionEnd) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1643,7 +1705,7 @@ func (m *TransactionPlannerRequest_ActionDutchAuctionWithdraw) String() string {
 }
 func (*TransactionPlannerRequest_ActionDutchAuctionWithdraw) ProtoMessage() {}
 func (*TransactionPlannerRequest_ActionDutchAuctionWithdraw) Descriptor() ([]byte, []int) {
-	return fileDescriptor_dba93d04e42ddfc3, []int{6, 11}
+	return fileDescriptor_dba93d04e42ddfc3, []int{6, 12}
 }
 func (m *TransactionPlannerRequest_ActionDutchAuctionWithdraw) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4624,6 +4686,7 @@ func init() {
 	proto.RegisterType((*BroadcastTransactionResponse_Confirmed)(nil), "penumbra.view.v1.BroadcastTransactionResponse.Confirmed")
 	proto.RegisterType((*TransactionPlannerRequest)(nil), "penumbra.view.v1.TransactionPlannerRequest")
 	proto.RegisterType((*TransactionPlannerRequest_Output)(nil), "penumbra.view.v1.TransactionPlannerRequest.Output")
+	proto.RegisterType((*TransactionPlannerRequest_Spend)(nil), "penumbra.view.v1.TransactionPlannerRequest.Spend")
 	proto.RegisterType((*TransactionPlannerRequest_Swap)(nil), "penumbra.view.v1.TransactionPlannerRequest.Swap")
 	proto.RegisterType((*TransactionPlannerRequest_SwapClaim)(nil), "penumbra.view.v1.TransactionPlannerRequest.SwapClaim")
 	proto.RegisterType((*TransactionPlannerRequest_Delegate)(nil), "penumbra.view.v1.TransactionPlannerRequest.Delegate")
@@ -4696,279 +4759,281 @@ func init() {
 func init() { proto.RegisterFile("penumbra/view/v1/view.proto", fileDescriptor_dba93d04e42ddfc3) }
 
 var fileDescriptor_dba93d04e42ddfc3 = []byte{
-	// 4352 bytes of a gzipped FileDescriptorProto
+	// 4380 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x3c, 0x4b, 0x6c, 0xdc, 0x48,
-	0x76, 0x66, 0x4b, 0x96, 0x5a, 0x4f, 0x6a, 0x75, 0xab, 0xc6, 0x92, 0xdb, 0x3d, 0xb6, 0xec, 0xe1,
+	0x76, 0x66, 0x4b, 0x96, 0x5a, 0x4f, 0x6a, 0x75, 0xab, 0xc6, 0x92, 0xdb, 0x3d, 0x1e, 0xd9, 0xe6,
 	0x7c, 0x2c, 0xdb, 0xb3, 0xad, 0x8f, 0x67, 0xe7, 0x63, 0x7b, 0xb0, 0xe9, 0xd6, 0xc7, 0x92, 0x2d,
 	0xcb, 0x3d, 0x94, 0x2c, 0xcf, 0xce, 0x7a, 0xc2, 0x54, 0x93, 0x25, 0x89, 0x31, 0x9b, 0xa4, 0x49,
-	0x76, 0xcb, 0x4a, 0xf6, 0x9c, 0x20, 0xbb, 0x08, 0x10, 0x64, 0x73, 0x4d, 0x02, 0x04, 0xd9, 0x04,
+	0x76, 0xcb, 0x4a, 0xf6, 0x9c, 0x20, 0xbb, 0x08, 0x10, 0x64, 0x73, 0x4d, 0x02, 0x04, 0xd8, 0x04,
 	0x48, 0x80, 0xb9, 0xe7, 0x94, 0xeb, 0x6e, 0x80, 0x00, 0x8b, 0x9c, 0xf6, 0x12, 0x60, 0x31, 0x73,
-	0xcb, 0x3d, 0xa7, 0x1c, 0x12, 0xb0, 0x3e, 0x6c, 0x92, 0x4d, 0xaa, 0xbb, 0x65, 0x6d, 0x80, 0x3d,
-	0x89, 0x7c, 0xf5, 0x7e, 0xf5, 0xaa, 0x58, 0xef, 0x57, 0x2d, 0x78, 0xdb, 0x21, 0x56, 0xbb, 0xd5,
-	0x74, 0xf1, 0x62, 0xc7, 0x20, 0xc7, 0x8b, 0x9d, 0x65, 0xfa, 0xb7, 0xea, 0xb8, 0xb6, 0x6f, 0xa3,
-	0x92, 0x18, 0xac, 0x52, 0x60, 0x67, 0xb9, 0x72, 0xe5, 0xd0, 0xb6, 0x0f, 0x4d, 0xb2, 0x48, 0xc7,
-	0x9b, 0xed, 0x83, 0x45, 0x6c, 0x9d, 0x30, 0xe4, 0xca, 0x7c, 0xc8, 0x49, 0xb3, 0x5d, 0xb2, 0x88,
-	0x1d, 0x27, 0xe0, 0x86, 0x1d, 0x87, 0x8f, 0xcb, 0x89, 0x71, 0xcf, 0x23, 0x3e, 0xc5, 0x08, 0x1e,
-	0x38, 0xce, 0x52, 0x1c, 0x47, 0xb3, 0x5b, 0x8e, 0x6d, 0x11, 0xcb, 0x5f, 0xc4, 0x6d, 0xcd, 0x37,
-	0x6c, 0x8b, 0xe2, 0xb3, 0x47, 0x4e, 0xb1, 0x90, 0x45, 0xa1, 0x93, 0xd7, 0x01, 0xb6, 0x4e, 0x5e,
-	0xf7, 0xc3, 0x3c, 0x20, 0x24, 0xc0, 0x3c, 0x20, 0xa4, 0x1f, 0xa6, 0xd1, 0xd4, 0x02, 0x4c, 0xa3,
-	0xa9, 0xf5, 0xc3, 0xf4, 0x34, 0x3a, 0x37, 0x4f, 0x13, 0x33, 0x7b, 0x90, 0x89, 0x79, 0x64, 0x10,
-	0x53, 0x27, 0xba, 0xea, 0xd8, 0xb6, 0x49, 0x69, 0xa2, 0x00, 0x4e, 0xfd, 0x61, 0x26, 0xb5, 0x8f,
-	0x5f, 0x52, 0xed, 0xe9, 0x03, 0xc7, 0xbe, 0x11, 0xc7, 0x7e, 0x49, 0x4e, 0xbc, 0x00, 0x25, 0xf8,
-	0x9b, 0xbe, 0x56, 0x56, 0xbb, 0x15, 0x20, 0x58, 0xed, 0x16, 0x1f, 0xaf, 0xc6, 0xc7, 0x7d, 0x17,
-	0x5b, 0x1e, 0x0e, 0x57, 0x20, 0xf2, 0xca, 0xf1, 0xdf, 0x4b, 0xe0, 0xbf, 0x3e, 0xc2, 0xde, 0x11,
-	0x45, 0xa5, 0x4f, 0xbd, 0x7a, 0xb9, 0x27, 0x8e, 0x6f, 0x2f, 0xfa, 0xcc, 0x4a, 0xbe, 0xb0, 0x92,
-	0xfc, 0xb3, 0x1c, 0x14, 0x6b, 0x6c, 0x7d, 0x3d, 0x85, 0xbc, 0x6a, 0x13, 0xcf, 0x47, 0x8f, 0x60,
-	0x1a, 0x6b, 0x9a, 0xdd, 0xb6, 0x7c, 0xf5, 0xc0, 0x30, 0x7d, 0xe2, 0x96, 0xa5, 0x1b, 0xd2, 0xc2,
-	0xe4, 0xca, 0xbb, 0xa1, 0x92, 0xd5, 0x40, 0x68, 0x95, 0x4e, 0xaf, 0xb3, 0x5c, 0xad, 0xe9, 0xba,
-	0x4b, 0x3c, 0x6f, 0xcb, 0xd2, 0xc9, 0x6b, 0xa5, 0xc0, 0x49, 0x37, 0x28, 0x25, 0xba, 0x05, 0x25,
-	0xc3, 0xd2, 0xcc, 0xb6, 0x4e, 0x54, 0xc3, 0x0a, 0x66, 0xd0, 0x21, 0xe5, 0xdc, 0x0d, 0x69, 0x21,
-	0xaf, 0x14, 0x39, 0x7c, 0x8b, 0x83, 0xd1, 0x87, 0x80, 0x5e, 0xb5, 0x89, 0x7b, 0xa2, 0x9a, 0xd8,
-	0x27, 0x9e, 0xaf, 0x7a, 0x3e, 0xf6, 0x49, 0x79, 0x84, 0x22, 0x97, 0xe8, 0xc8, 0x36, 0x1d, 0xd8,
-	0x0d, 0xe0, 0xe8, 0x47, 0x80, 0xf8, 0xbe, 0x54, 0x0d, 0xdd, 0x13, 0x8a, 0x8e, 0xde, 0x18, 0x59,
-	0x98, 0x5c, 0xf9, 0x5e, 0x42, 0xd1, 0x70, 0xf5, 0xaa, 0x62, 0x2b, 0x07, 0x5a, 0xb3, 0xc7, 0x2d,
-	0x5d, 0x29, 0x61, 0xf1, 0xe8, 0x31, 0xad, 0xe5, 0x6f, 0x72, 0x50, 0xea, 0x5a, 0xc5, 0x73, 0x6c,
-	0xcb, 0x23, 0xe8, 0x73, 0xc8, 0x19, 0x3a, 0x37, 0xc5, 0x90, 0x12, 0x72, 0x86, 0x8e, 0xaa, 0x30,
-	0xce, 0xc7, 0xa8, 0x01, 0x26, 0x57, 0x2e, 0x55, 0xd9, 0xa7, 0x5d, 0x15, 0x9f, 0x76, 0xb5, 0x66,
-	0x9d, 0x28, 0x02, 0x09, 0x6d, 0xc0, 0x84, 0x63, 0x7b, 0x06, 0xd5, 0xa1, 0x3c, 0x42, 0xe7, 0xb5,
-	0x90, 0x29, 0x35, 0xf8, 0xe8, 0x3a, 0xcb, 0xd5, 0x06, 0x27, 0x50, 0xba, 0xa4, 0x68, 0x03, 0x26,
-	0x2d, 0xdb, 0x27, 0xaa, 0x4b, 0x34, 0xdb, 0xd5, 0xcb, 0xa3, 0x54, 0xf6, 0xfb, 0xd5, 0xe4, 0x41,
-	0x53, 0xdd, 0x75, 0x88, 0xa5, 0xe3, 0xa6, 0x49, 0x76, 0x6c, 0x9f, 0x28, 0x14, 0x59, 0x01, 0x2b,
-	0x7c, 0x46, 0x6f, 0xc3, 0x84, 0x69, 0x6b, 0xd8, 0x54, 0x3d, 0xf2, 0xaa, 0x7c, 0xf1, 0x86, 0xb4,
-	0x30, 0xaa, 0xe4, 0x29, 0x60, 0x97, 0xbc, 0x92, 0x7d, 0x28, 0xd7, 0xda, 0xfe, 0x91, 0xed, 0x1a,
-	0x7f, 0x44, 0x6a, 0x96, 0x5e, 0x6f, 0x1b, 0xa6, 0x2e, 0xb6, 0xd3, 0x97, 0x50, 0x8a, 0xec, 0x5f,
-	0xd5, 0x31, 0xb1, 0x95, 0x61, 0xc5, 0xe8, 0x36, 0xef, 0x2c, 0x57, 0xf7, 0xba, 0xaf, 0x0d, 0x13,
-	0x5b, 0x4a, 0xd1, 0x8f, 0x03, 0xe4, 0xef, 0x72, 0x70, 0x25, 0x45, 0x2c, 0x5f, 0xaf, 0x26, 0x4c,
-	0x37, 0x03, 0x80, 0xea, 0xb8, 0xf6, 0x61, 0xb0, 0x41, 0xb9, 0xd4, 0xcf, 0x7a, 0xe7, 0x9e, 0xc9,
-	0xa4, 0x4a, 0xdf, 0x1a, 0x9c, 0xc1, 0xe6, 0x05, 0xa5, 0xd0, 0x8c, 0x02, 0x90, 0x02, 0xf9, 0x60,
-	0x11, 0x4c, 0xe2, 0x13, 0xbe, 0xaa, 0x1f, 0x0d, 0xc3, 0x7d, 0x95, 0xd3, 0x6e, 0x5e, 0x50, 0x42,
-	0x3e, 0x95, 0x3b, 0x50, 0x88, 0x49, 0x45, 0x15, 0xc8, 0xc7, 0xa6, 0x90, 0x53, 0xc2, 0xf7, 0xca,
-	0x73, 0xc8, 0x0b, 0x26, 0xe8, 0x31, 0x4c, 0x46, 0x2c, 0xc4, 0x67, 0x7b, 0x6b, 0x60, 0x1b, 0x2b,
-	0x51, 0xea, 0x7a, 0x1e, 0xc6, 0x82, 0x0f, 0xb0, 0xed, 0xc9, 0x3f, 0x93, 0xe0, 0xed, 0xba, 0x6b,
-	0x63, 0x5d, 0xc3, 0x9e, 0x1f, 0xc5, 0xe7, 0xeb, 0x7b, 0x9e, 0x62, 0xd1, 0x4d, 0x28, 0xe2, 0x63,
-	0x6c, 0xf8, 0xaa, 0x4e, 0x7c, 0xd2, 0xfd, 0x5a, 0xf2, 0xca, 0x34, 0x05, 0xaf, 0x09, 0xa8, 0xfc,
-	0xcd, 0x08, 0x5c, 0x4d, 0xd7, 0x8a, 0x2f, 0xbf, 0x05, 0x33, 0x4d, 0x31, 0xae, 0x7a, 0x6d, 0x4d,
-	0xeb, 0xee, 0x80, 0x1f, 0xf4, 0xae, 0xd1, 0x69, 0xac, 0xba, 0x83, 0xbb, 0x8c, 0xcd, 0xe6, 0x05,
-	0xa5, 0xd4, 0x4c, 0xc0, 0xd0, 0x97, 0x30, 0xa1, 0xd9, 0xd6, 0x81, 0xe1, 0xb6, 0x88, 0xce, 0xf7,
-	0xc2, 0xa7, 0x43, 0xca, 0x59, 0x15, 0xf4, 0x9b, 0x17, 0x94, 0x2e, 0xb3, 0xca, 0x23, 0x28, 0x25,
-	0x35, 0x40, 0x1f, 0x47, 0x0e, 0xa3, 0x0f, 0x92, 0xb6, 0x66, 0x2e, 0x20, 0x6e, 0x66, 0x76, 0x0a,
-	0x55, 0x2c, 0x98, 0x08, 0xa5, 0x9c, 0x95, 0x49, 0x70, 0xa8, 0x87, 0xcb, 0xa3, 0x1e, 0x11, 0xe3,
-	0xf0, 0xc8, 0xa7, 0x33, 0x1e, 0x55, 0x8a, 0x21, 0x7c, 0x93, 0x82, 0x23, 0xdb, 0xe8, 0xef, 0xaf,
-	0xc1, 0x95, 0xc4, 0x17, 0x6d, 0x11, 0x57, 0x6c, 0xa2, 0x77, 0xa1, 0x40, 0x5e, 0x3b, 0x86, 0x7b,
-	0x22, 0xf8, 0x49, 0x94, 0xdf, 0x14, 0x03, 0x32, 0x66, 0xe8, 0x07, 0x30, 0xda, 0x22, 0x2d, 0x9b,
-	0xfa, 0x84, 0xc9, 0x95, 0x3b, 0xa7, 0x6f, 0xb1, 0x27, 0xa4, 0x65, 0x37, 0x4c, 0x6c, 0x58, 0x3e,
-	0x79, 0xed, 0x2b, 0x94, 0x10, 0xdd, 0x87, 0x31, 0xcf, 0x6e, 0xbb, 0x1a, 0xe1, 0xc7, 0xe0, 0x40,
-	0x1e, 0x8d, 0x93, 0xa0, 0x6d, 0x18, 0xb7, 0xdb, 0xbe, 0xd3, 0xf6, 0xbd, 0xf2, 0x25, 0x7a, 0x1c,
-	0xaf, 0xf4, 0x2e, 0x6f, 0xe6, 0x04, 0xab, 0x4f, 0x29, 0xa9, 0x22, 0x58, 0xa0, 0x0d, 0xb8, 0xe8,
-	0x1d, 0x63, 0xc7, 0x2b, 0xcf, 0x53, 0x5e, 0x4b, 0xc3, 0xf0, 0xda, 0x3d, 0xc6, 0x8e, 0xc2, 0xc8,
-	0xd1, 0x3e, 0x4c, 0x06, 0x0f, 0xaa, 0x66, 0x62, 0xa3, 0xe5, 0x95, 0xaf, 0x53, 0x6e, 0xdf, 0x1f,
-	0x96, 0xdb, 0x6a, 0x40, 0xad, 0x80, 0x27, 0x1e, 0x29, 0x5f, 0x9d, 0x98, 0xe4, 0x10, 0x33, 0x07,
-	0xb4, 0x40, 0xf9, 0x7e, 0x34, 0x0c, 0xdf, 0x35, 0x46, 0x4e, 0x94, 0x28, 0x23, 0xf4, 0x02, 0x0a,
-	0x6d, 0x2b, 0xca, 0x79, 0x85, 0x72, 0xfe, 0x78, 0x18, 0xce, 0xcf, 0x04, 0x03, 0xa2, 0xc4, 0x99,
-	0x21, 0x13, 0xde, 0x8a, 0x02, 0x84, 0x55, 0xee, 0x52, 0x19, 0xf7, 0xcf, 0x26, 0x83, 0xd9, 0x06,
-	0x45, 0xf9, 0x72, 0x1b, 0xed, 0xc1, 0x8c, 0xd1, 0xd4, 0x54, 0x97, 0x98, 0xf8, 0x44, 0x65, 0x5c,
-	0xbc, 0xf2, 0x83, 0x3e, 0xae, 0x3a, 0x88, 0x65, 0x3b, 0xcb, 0xd5, 0xad, 0xa6, 0xa6, 0x04, 0x74,
-	0x4a, 0xd1, 0xe0, 0x4f, 0x35, 0x4d, 0x58, 0x68, 0xc6, 0xd0, 0xbc, 0x95, 0x25, 0xf5, 0xd8, 0xf0,
-	0x8f, 0x74, 0x17, 0x1f, 0x63, 0xd3, 0x2b, 0x7f, 0x4e, 0xb9, 0x2e, 0xf6, 0xe5, 0x1a, 0x10, 0x3e,
-	0x0f, 0xe9, 0x94, 0x92, 0x11, 0x07, 0x78, 0x48, 0x85, 0x69, 0x11, 0x1b, 0xa8, 0xb6, 0x43, 0x2c,
-	0xaf, 0xbc, 0x41, 0x59, 0x7f, 0x3a, 0x8c, 0x71, 0x44, 0x9c, 0xf1, 0xd4, 0x21, 0x96, 0x52, 0x70,
-	0x22, 0x6f, 0x1e, 0x6a, 0x42, 0x31, 0x14, 0xa0, 0x99, 0xb6, 0x47, 0xbc, 0xf2, 0x43, 0x2a, 0xe1,
-	0xb3, 0xb3, 0x48, 0x58, 0x0d, 0x38, 0x28, 0xa1, 0xca, 0xf4, 0xd5, 0x43, 0x2f, 0x01, 0x85, 0x32,
-	0x84, 0x95, 0xbc, 0xf2, 0x26, 0x15, 0xf3, 0xe0, 0x2c, 0x62, 0x84, 0x85, 0x94, 0x19, 0x27, 0x01,
-	0xf1, 0xd0, 0x4f, 0x25, 0x98, 0xd7, 0xdb, 0xbe, 0x76, 0xa4, 0x8a, 0x80, 0xd3, 0xd3, 0x8e, 0x88,
-	0xde, 0x36, 0x49, 0xb8, 0xe6, 0x5b, 0x54, 0xf2, 0xc6, 0x30, 0x92, 0xd9, 0x6a, 0xaf, 0x05, 0x7c,
-	0x79, 0x9c, 0xb8, 0xcb, 0xb9, 0x2a, 0x6f, 0xeb, 0x29, 0x50, 0xb1, 0x3b, 0x7e, 0x0c, 0x57, 0xe2,
-	0xca, 0x10, 0x4b, 0x0f, 0xf5, 0x78, 0x44, 0xf5, 0xa8, 0xbd, 0x99, 0x1e, 0xeb, 0x96, 0xae, 0xcc,
-	0xe9, 0x71, 0x80, 0x90, 0xde, 0x6b, 0x0b, 0x61, 0xfe, 0x50, 0x87, 0xc7, 0xe7, 0x61, 0x8b, 0x70,
-	0x3d, 0x62, 0xb6, 0x10, 0x50, 0xa1, 0xcd, 0x1a, 0xe4, 0x71, 0xdb, 0xb7, 0xd5, 0x03, 0x42, 0xca,
-	0x3a, 0x3d, 0xd0, 0x6f, 0x66, 0x7e, 0x20, 0x41, 0xb2, 0xd9, 0x59, 0xae, 0x6e, 0x10, 0xb2, 0x67,
-	0x10, 0x77, 0xf3, 0x42, 0x10, 0x68, 0xfb, 0xf6, 0x06, 0x21, 0x68, 0x0d, 0xa0, 0x85, 0xad, 0x36,
-	0x36, 0x29, 0x1f, 0x92, 0xea, 0x18, 0xd2, 0xf8, 0x04, 0x4e, 0x9a, 0x11, 0x06, 0x5c, 0xde, 0x83,
-	0x49, 0xe2, 0xd8, 0xda, 0x91, 0x6a, 0x04, 0x4e, 0xa3, 0xfc, 0x0b, 0xea, 0xbf, 0xea, 0xb9, 0xb2,
-	0xa4, 0x00, 0x85, 0x53, 0x5f, 0x82, 0x1e, 0xc0, 0x45, 0xfa, 0x56, 0xfe, 0xa5, 0x94, 0x8c, 0xc3,
-	0x13, 0x72, 0x82, 0x44, 0xb6, 0xb3, 0x5c, 0x5d, 0x0f, 0xb0, 0x15, 0x46, 0x54, 0x39, 0x86, 0x31,
-	0xe6, 0x46, 0xd0, 0x5d, 0xb8, 0xd8, 0xc1, 0x66, 0x9b, 0x70, 0xe7, 0x7d, 0x2d, 0xc1, 0x86, 0x65,
-	0xf8, 0x9d, 0xe5, 0xea, 0x7e, 0x80, 0xa4, 0x30, 0x5c, 0xf4, 0x29, 0x8c, 0x63, 0xe6, 0xd8, 0x78,
-	0x7c, 0x32, 0x7f, 0xba, 0xfb, 0x53, 0x04, 0x7a, 0xe5, 0x7f, 0x24, 0x18, 0x0d, 0xdc, 0xc4, 0xd9,
-	0xe4, 0xd6, 0x61, 0xca, 0xc7, 0xee, 0x21, 0xf1, 0x55, 0x3a, 0xce, 0x85, 0x5f, 0xcf, 0xa2, 0xad,
-	0x05, 0x0f, 0x5b, 0xba, 0x32, 0xc9, 0x88, 0xe8, 0x2b, 0xfa, 0x3e, 0x8c, 0x04, 0xab, 0x33, 0x32,
-	0xf0, 0xea, 0x28, 0x01, 0x3e, 0x5a, 0x85, 0x02, 0x75, 0x01, 0xaa, 0x98, 0xf8, 0xe8, 0x40, 0x13,
-	0x9f, 0xa2, 0x44, 0xfc, 0xad, 0xf2, 0x35, 0x4c, 0x84, 0x3e, 0x12, 0x35, 0xa0, 0xc8, 0xfc, 0xad,
-	0xdd, 0x6a, 0x19, 0x7e, 0x8b, 0x58, 0x3e, 0xb7, 0x45, 0x74, 0xeb, 0xd1, 0x64, 0xbb, 0xea, 0xb3,
-	0x25, 0xa4, 0xf9, 0xea, 0x6a, 0x88, 0xae, 0x4c, 0x53, 0x2f, 0x1b, 0xbe, 0x57, 0xfe, 0x4c, 0x82,
-	0xbc, 0xf0, 0x95, 0xe8, 0x23, 0x18, 0xc3, 0xad, 0x20, 0x7f, 0xe6, 0x5c, 0xaf, 0x26, 0x34, 0xb5,
-	0xda, 0x2d, 0xaa, 0x28, 0xc5, 0x51, 0x38, 0x2e, 0x7a, 0x08, 0x13, 0x2e, 0xf6, 0x89, 0xaa, 0x63,
-	0x1f, 0x73, 0x1b, 0xdd, 0xce, 0xde, 0x59, 0xb4, 0x70, 0xd1, 0x59, 0xae, 0x2a, 0xd8, 0x27, 0x6b,
-	0xd8, 0xc7, 0x4a, 0xde, 0xe5, 0x4f, 0x95, 0x9f, 0x48, 0x00, 0x5d, 0xcf, 0x77, 0xb6, 0xe5, 0x8e,
-	0x29, 0x93, 0x7b, 0x03, 0x65, 0x7e, 0x9d, 0x83, 0x62, 0xc2, 0x0d, 0xa3, 0x2f, 0x00, 0x75, 0xb0,
-	0x69, 0xe8, 0xd8, 0xb7, 0x5d, 0xd5, 0xd0, 0x89, 0xe5, 0x1b, 0xfe, 0x09, 0x57, 0x4f, 0xce, 0x58,
-	0xd5, 0x2d, 0x8e, 0xf6, 0x98, 0x9c, 0x28, 0x33, 0x21, 0xb5, 0x80, 0xa2, 0x2a, 0xcc, 0x78, 0x3e,
-	0x76, 0x7d, 0x35, 0xfa, 0xfd, 0xe6, 0xc2, 0xcf, 0xb7, 0x48, 0x07, 0xd7, 0xbb, 0xdf, 0xf0, 0x2a,
-	0x8c, 0x3b, 0xc4, 0xc2, 0xa6, 0x7f, 0xc2, 0x4d, 0x7d, 0xab, 0xff, 0xec, 0x1a, 0x8c, 0x40, 0x11,
-	0x94, 0xe8, 0x21, 0x94, 0xda, 0x56, 0xd3, 0xb6, 0x74, 0xc3, 0x3a, 0x54, 0xf9, 0x8a, 0x8f, 0x0e,
-	0xb0, 0xe2, 0xc5, 0x90, 0x8a, 0x01, 0xd0, 0x47, 0x30, 0xd7, 0x65, 0xc4, 0xe6, 0xc1, 0x23, 0x68,
-	0x96, 0xa3, 0x5f, 0x0a, 0x47, 0x77, 0x83, 0x41, 0x16, 0x49, 0x57, 0xf6, 0x60, 0x2a, 0xea, 0xc3,
-	0x83, 0x93, 0x54, 0x38, 0x3e, 0x6e, 0xcc, 0xc1, 0x6b, 0x0d, 0x21, 0x65, 0xe5, 0x05, 0x14, 0x62,
-	0x7e, 0x3b, 0x48, 0x0d, 0x43, 0x3f, 0x1d, 0x66, 0x1a, 0xb7, 0x07, 0xe5, 0xbc, 0xa5, 0x2b, 0xe0,
-	0x84, 0xcf, 0x95, 0xff, 0x96, 0xa0, 0x94, 0xf4, 0xd7, 0xe7, 0x2a, 0x21, 0xb0, 0x82, 0x4b, 0x3c,
-	0xe2, 0x76, 0x88, 0x38, 0x21, 0xfb, 0x5a, 0x41, 0xe1, 0xf8, 0x4a, 0x48, 0x89, 0x76, 0x60, 0xca,
-	0x77, 0x31, 0x5d, 0x0f, 0x07, 0x1b, 0x6e, 0x46, 0xb6, 0xd2, 0xc3, 0x69, 0x8f, 0xd1, 0x34, 0xb0,
-	0xe1, 0xd2, 0x94, 0x58, 0xbc, 0x54, 0xfe, 0x18, 0x2a, 0xd9, 0xc1, 0x02, 0xfa, 0x3a, 0x88, 0xd3,
-	0x3d, 0xcd, 0x35, 0x9c, 0xc8, 0xe2, 0xdd, 0x1f, 0xa4, 0x3c, 0x15, 0x65, 0xb7, 0xd6, 0x65, 0xa1,
-	0x44, 0xf9, 0x55, 0x08, 0xcc, 0xa6, 0x46, 0x08, 0x68, 0x1b, 0xa0, 0x5b, 0x7f, 0x3b, 0x5b, 0x55,
-	0x6c, 0x22, 0xac, 0xbb, 0x55, 0x7e, 0x9c, 0x36, 0xc7, 0x70, 0x91, 0xcf, 0x55, 0x16, 0x2a, 0xc1,
-	0x88, 0x47, 0x5e, 0xf1, 0x84, 0x35, 0x78, 0xac, 0x03, 0xe4, 0x0f, 0x08, 0x51, 0x5b, 0xb6, 0x4e,
-	0x64, 0x15, 0x2a, 0x69, 0x81, 0x0a, 0x2f, 0x2a, 0xd4, 0x60, 0xf4, 0xec, 0xf5, 0x2b, 0x4a, 0x2a,
-	0x63, 0x98, 0xe5, 0x8e, 0xa5, 0x7e, 0xc2, 0x12, 0x4c, 0x9e, 0x02, 0x6f, 0x42, 0x81, 0x7b, 0x29,
-	0x7e, 0x06, 0x0d, 0x51, 0x75, 0x9d, 0xc2, 0x91, 0x37, 0x59, 0x81, 0xb9, 0xa4, 0x08, 0xae, 0x7f,
-	0x24, 0x04, 0x90, 0x86, 0x0a, 0x01, 0xe4, 0x19, 0x28, 0x3e, 0xc7, 0xa6, 0x49, 0x3d, 0x33, 0x53,
-	0x58, 0x6e, 0x40, 0xa9, 0x0b, 0xe2, 0x02, 0x1e, 0xc0, 0xc4, 0x31, 0x85, 0x75, 0x57, 0xea, 0x7a,
-	0x86, 0x88, 0x90, 0x36, 0x7f, 0xcc, 0x9f, 0xe4, 0x2f, 0x60, 0x96, 0xea, 0x5b, 0x3f, 0x11, 0xf2,
-	0xb9, 0x6d, 0xce, 0xae, 0x77, 0x13, 0xe6, 0x92, 0x2c, 0xb9, 0xaa, 0xe7, 0x67, 0x6f, 0x0d, 0x2e,
-	0xaf, 0x3b, 0x47, 0xa4, 0x45, 0x5c, 0x6c, 0x26, 0x14, 0x3f, 0x3f, 0x21, 0x7b, 0x50, 0xee, 0x15,
-	0xf2, 0xc6, 0xcb, 0xfa, 0x0f, 0x12, 0x14, 0xeb, 0xd8, 0xc4, 0x96, 0x46, 0x7e, 0x2b, 0xf5, 0xff,
-	0x87, 0x50, 0xa4, 0x51, 0x82, 0x6a, 0xe8, 0x82, 0xd9, 0x80, 0xe1, 0x5f, 0x01, 0xb3, 0x07, 0x5e,
-	0x92, 0xff, 0x79, 0x0e, 0x4a, 0x5d, 0x45, 0xc3, 0xcf, 0x71, 0x9c, 0x8b, 0x1b, 0x42, 0x45, 0xea,
-	0xd5, 0x05, 0x1d, 0xba, 0x0f, 0xe3, 0x4d, 0xc6, 0x96, 0x2b, 0x76, 0x7a, 0x90, 0xc3, 0x88, 0x39,
-	0x05, 0x7a, 0x0c, 0x45, 0x61, 0x29, 0x61, 0xff, 0x91, 0x53, 0x43, 0x11, 0xae, 0xc7, 0xbe, 0x41,
-	0x8e, 0x15, 0x61, 0x64, 0x0e, 0x43, 0x6b, 0x30, 0xc5, 0xf9, 0xaa, 0x41, 0xca, 0xc4, 0xc3, 0x81,
-	0x77, 0x4e, 0x55, 0x87, 0x32, 0x9a, 0xe4, 0x64, 0xc1, 0x8b, 0x5c, 0x84, 0xc2, 0x2e, 0x2d, 0xb8,
-	0x89, 0xaf, 0xf4, 0xa7, 0x12, 0x4c, 0x0b, 0x08, 0x37, 0xdb, 0x02, 0x94, 0x0e, 0xda, 0xa6, 0xa9,
-	0x7a, 0x27, 0x96, 0x16, 0xaf, 0xb7, 0x4d, 0x07, 0xf0, 0xdd, 0x13, 0x4b, 0xe3, 0x15, 0xb7, 0x2a,
-	0xbc, 0xe5, 0x60, 0xd7, 0x37, 0x70, 0x1c, 0x99, 0x9d, 0x9d, 0x33, 0x7c, 0x28, 0x82, 0x7f, 0x1d,
-	0x26, 0x35, 0xec, 0x6b, 0x47, 0x81, 0xf3, 0x6b, 0x3b, 0xbc, 0x79, 0x03, 0x02, 0xf4, 0xcc, 0x91,
-	0x67, 0xe1, 0x2d, 0xa6, 0xcc, 0xae, 0xef, 0x12, 0xdc, 0x12, 0x4a, 0xfe, 0xb3, 0x04, 0x97, 0xe2,
-	0x70, 0xae, 0xea, 0x67, 0x70, 0x85, 0xb7, 0x83, 0x5e, 0x5a, 0xf6, 0xb1, 0xa5, 0x36, 0x4d, 0x5b,
-	0x7b, 0x19, 0xd7, 0x79, 0x8e, 0x21, 0x3c, 0x0e, 0xc6, 0xeb, 0xc1, 0x30, 0xd7, 0x25, 0x6d, 0x96,
-	0xb9, 0x61, 0x66, 0x39, 0x92, 0x31, 0x4b, 0xf9, 0x7f, 0x25, 0x98, 0xda, 0xb1, 0xfd, 0xee, 0x17,
-	0xf3, 0x2e, 0x14, 0x44, 0x97, 0xcb, 0x73, 0x82, 0x94, 0x80, 0xd5, 0xac, 0xa7, 0x38, 0x70, 0x37,
-	0x80, 0xa1, 0x7b, 0x90, 0x17, 0x9f, 0x02, 0xdf, 0x25, 0x7d, 0xbf, 0x81, 0x71, 0xfe, 0x0d, 0xf4,
-	0x1e, 0x23, 0xa3, 0x67, 0x3c, 0x46, 0xd0, 0x1a, 0x14, 0x59, 0xb8, 0xa9, 0xfa, 0x36, 0x55, 0x56,
-	0x2f, 0x8f, 0x0d, 0x10, 0x77, 0x16, 0x18, 0xd1, 0x9e, 0x4d, 0xdb, 0x44, 0xf2, 0x9f, 0x4b, 0x30,
-	0x4b, 0x2d, 0xb0, 0x61, 0xbb, 0xfb, 0xb6, 0x6f, 0x58, 0x87, 0xc2, 0x14, 0xb7, 0x61, 0xa6, 0x63,
-	0xfb, 0xb8, 0x69, 0x12, 0x15, 0xfb, 0xf1, 0x85, 0x2a, 0xf2, 0x81, 0x1a, 0x8f, 0x42, 0x7b, 0x67,
-	0x35, 0x72, 0xd6, 0xc3, 0xf1, 0x0f, 0x61, 0xfa, 0xb9, 0xe1, 0x5b, 0x91, 0x83, 0x37, 0xad, 0xeb,
-	0x34, 0x72, 0x2e, 0x5d, 0x27, 0x15, 0x8a, 0xa1, 0x2c, 0xbe, 0x4b, 0xb7, 0x61, 0xea, 0x98, 0x81,
-	0x58, 0xd6, 0x33, 0x50, 0x0f, 0x84, 0x33, 0xa1, 0x49, 0xcf, 0xe4, 0x71, 0xf7, 0x45, 0xfe, 0x0f,
-	0x09, 0xe6, 0xf8, 0xe0, 0xff, 0x5b, 0x2f, 0x0d, 0xfd, 0x3e, 0x20, 0xcc, 0xfb, 0x54, 0xac, 0x74,
-	0x1a, 0x49, 0xdf, 0x16, 0x4f, 0xe7, 0x5d, 0x8b, 0xd2, 0xd1, 0xe9, 0xcc, 0xe0, 0x24, 0x48, 0xfe,
-	0xcf, 0x1c, 0x5c, 0xee, 0x99, 0x14, 0x37, 0xdf, 0x1f, 0x64, 0x74, 0xea, 0x3e, 0xe9, 0x2d, 0x22,
-	0x65, 0xb0, 0xe8, 0xd7, 0xa7, 0x6b, 0xf4, 0xf4, 0xe9, 0x56, 0x06, 0xe7, 0xfd, 0x3b, 0xd1, 0xa5,
-	0xfb, 0xf9, 0x08, 0x14, 0xe8, 0xb1, 0x11, 0x7e, 0x01, 0x15, 0xc8, 0x33, 0x8f, 0x4b, 0x58, 0x24,
-	0x96, 0x57, 0xc2, 0x77, 0xa4, 0xc1, 0x7c, 0xe4, 0xc0, 0xd2, 0x8c, 0x03, 0x43, 0x53, 0x75, 0x62,
-	0xd9, 0x2d, 0xc3, 0xe2, 0x65, 0xf9, 0x1c, 0x2d, 0xe3, 0x65, 0x3a, 0xc3, 0xb5, 0x00, 0x59, 0xb9,
-	0xda, 0x3d, 0xe0, 0x28, 0x8f, 0xb5, 0x28, 0x0b, 0x74, 0x0f, 0xae, 0x08, 0x21, 0x91, 0x92, 0xbc,
-	0x6f, 0xbf, 0x24, 0x96, 0xc7, 0x5d, 0xc3, 0x65, 0x8e, 0xb0, 0x16, 0x8e, 0xef, 0xd1, 0x61, 0xf4,
-	0x29, 0x94, 0x05, 0x6d, 0x37, 0xbd, 0xe5, 0xa4, 0xa3, 0x94, 0x74, 0x8e, 0x8f, 0x3f, 0x13, 0xc3,
-	0x9c, 0xf2, 0x03, 0x10, 0x37, 0x0b, 0x54, 0xd3, 0x51, 0xad, 0x03, 0xdf, 0xa3, 0x99, 0x70, 0x5e,
-	0x11, 0x47, 0xf4, 0xb6, 0xb3, 0x73, 0xe0, 0x7b, 0x68, 0x05, 0x66, 0x05, 0x9e, 0xe3, 0xda, 0x8e,
-	0xed, 0x61, 0x93, 0x61, 0x8f, 0x51, 0xec, 0xb7, 0xf8, 0x60, 0x83, 0x8f, 0x51, 0x9a, 0x1a, 0x5c,
-	0x13, 0x34, 0x1d, 0x7a, 0xea, 0xa9, 0x2e, 0xd1, 0x88, 0xe1, 0xf8, 0x42, 0xb5, 0x71, 0x4a, 0x5b,
-	0xe1, 0x48, 0xe2, 0x64, 0xa4, 0x28, 0x4c, 0x3d, 0xf9, 0x87, 0x30, 0x2d, 0x96, 0x89, 0xef, 0xfe,
-	0x87, 0x30, 0x4d, 0x4d, 0xaf, 0xb6, 0x88, 0x8f, 0x23, 0x5f, 0xdd, 0x8d, 0x2c, 0xdb, 0x3f, 0xe1,
-	0x78, 0x4a, 0x81, 0xd2, 0x89, 0x57, 0x79, 0x0e, 0x2e, 0xd5, 0x1c, 0xa7, 0x81, 0x5d, 0xdc, 0x22,
-	0x3e, 0x71, 0xc3, 0x08, 0xe0, 0x05, 0xcc, 0x26, 0xe0, 0x5c, 0xf2, 0x2a, 0x80, 0x13, 0x42, 0x33,
-	0x22, 0x28, 0xec, 0x38, 0xf4, 0x1b, 0x8f, 0x31, 0x88, 0x90, 0xc9, 0x08, 0x4a, 0x0f, 0xb1, 0xd7,
-	0x70, 0x8d, 0x6e, 0x04, 0x29, 0x7f, 0x23, 0xc1, 0x4c, 0x04, 0x18, 0x06, 0xdc, 0x70, 0x88, 0x3d,
-	0xd5, 0xa1, 0xd0, 0x8c, 0x8d, 0xdf, 0x53, 0xca, 0xeb, 0xb2, 0x99, 0x38, 0x14, 0x8f, 0xe8, 0x29,
-	0x4c, 0x63, 0xd3, 0x57, 0x23, 0xdc, 0xd8, 0x76, 0x1d, 0x82, 0xdb, 0x14, 0x36, 0xfd, 0xf0, 0x2d,
-	0x30, 0xdd, 0xc6, 0x93, 0xb5, 0x5e, 0xd3, 0x39, 0x30, 0x9b, 0x80, 0xf3, 0xb9, 0x3c, 0x4f, 0x31,
-	0xdd, 0x27, 0xd9, 0x75, 0xa0, 0xd8, 0x0d, 0xa3, 0xce, 0x72, 0x75, 0xa3, 0xa5, 0x67, 0x98, 0xf3,
-	0xaf, 0x24, 0xb8, 0x1c, 0x78, 0xd6, 0xfa, 0x49, 0xa4, 0x64, 0xc8, 0xbf, 0xe8, 0x06, 0x14, 0xe9,
-	0x55, 0x8e, 0x48, 0xed, 0x31, 0x37, 0x64, 0xed, 0x31, 0xa0, 0xef, 0xbe, 0xa7, 0xb5, 0xdb, 0x47,
-	0x52, 0xdb, 0xed, 0x47, 0x50, 0xee, 0xd5, 0x2a, 0xf4, 0x7e, 0xd3, 0x9e, 0xb8, 0x3c, 0xa2, 0x06,
-	0x02, 0xca, 0xd2, 0x30, 0x97, 0x4c, 0x0a, 0x5e, 0x14, 0x48, 0x0d, 0xb0, 0x7b, 0x8c, 0x9d, 0x0c,
-	0x03, 0x24, 0x8b, 0xaf, 0xb9, 0x37, 0x2a, 0xbe, 0x0e, 0x6e, 0x80, 0x6d, 0x28, 0xf7, 0x6a, 0xc5,
-	0x0d, 0xb0, 0x04, 0xa3, 0x01, 0xdb, 0xde, 0x92, 0x6d, 0x38, 0xed, 0x63, 0xec, 0xf0, 0xd9, 0x52,
-	0x4c, 0xf9, 0x32, 0xcc, 0x3e, 0xb3, 0x68, 0x91, 0x99, 0xe8, 0xc1, 0x60, 0xb8, 0xe1, 0x1e, 0xc1,
-	0x5c, 0x72, 0xe0, 0xcc, 0x42, 0x7e, 0x22, 0xc1, 0xdc, 0x4e, 0xdb, 0x34, 0x8d, 0x03, 0x83, 0xb8,
-	0xb1, 0xa4, 0x00, 0x3d, 0x84, 0x09, 0x4b, 0x8c, 0x70, 0x13, 0xde, 0xea, 0xd7, 0x8a, 0x08, 0x59,
-	0x29, 0x5d, 0xda, 0xc1, 0xed, 0xb7, 0x08, 0x97, 0x7b, 0x74, 0xe1, 0x33, 0xbb, 0x04, 0x17, 0x59,
-	0xd4, 0xcc, 0xbc, 0x14, 0x7b, 0x91, 0xf7, 0xe1, 0x6a, 0xf4, 0xe6, 0x81, 0x75, 0x60, 0xd7, 0x4f,
-	0x36, 0xb1, 0x77, 0x24, 0xa6, 0xc0, 0x2e, 0x2f, 0xe4, 0x86, 0xbd, 0xbc, 0x20, 0x7f, 0x05, 0x73,
-	0x09, 0xbe, 0x82, 0xe3, 0x3b, 0x30, 0x15, 0x2b, 0xa0, 0xb2, 0xa8, 0x75, 0xd2, 0xeb, 0xd6, 0x4d,
-	0xd1, 0x35, 0x00, 0x62, 0xe9, 0xf1, 0x6c, 0x62, 0x82, 0x58, 0x3a, 0x4f, 0x0c, 0x7e, 0x99, 0x83,
-	0x62, 0x82, 0x39, 0x9a, 0x83, 0xb1, 0x18, 0x3f, 0xfe, 0x76, 0x56, 0xfd, 0x93, 0xf1, 0xc3, 0xc8,
-	0x1b, 0x5d, 0xb7, 0xd9, 0x87, 0x49, 0x87, 0xb8, 0x41, 0x08, 0x40, 0x6f, 0xe6, 0x8d, 0x26, 0xaf,
-	0x30, 0xf5, 0x0b, 0x25, 0xbb, 0xb4, 0x4a, 0x94, 0x11, 0xaa, 0xc1, 0x28, 0xcd, 0x61, 0x2f, 0x0e,
-	0x19, 0x9b, 0xd2, 0x7c, 0x96, 0x92, 0xca, 0xcf, 0xe0, 0x72, 0xcf, 0x3a, 0xf1, 0x0d, 0x73, 0x0f,
-	0xc6, 0xfd, 0xd7, 0xaa, 0x61, 0x1d, 0xd8, 0xfc, 0x6b, 0x78, 0xe7, 0xd4, 0x6e, 0x23, 0xa5, 0x1d,
-	0xf3, 0x5f, 0x07, 0x7f, 0xe5, 0x1f, 0xc1, 0xb5, 0x8c, 0x6d, 0x75, 0x0e, 0xcc, 0x9f, 0x43, 0x81,
-	0xe7, 0x85, 0x9c, 0x59, 0xe2, 0xf2, 0x9d, 0x74, 0xc6, 0xcb, 0x77, 0xf2, 0x3f, 0x06, 0x9f, 0x72,
-	0x22, 0xdf, 0x3a, 0x5f, 0x11, 0x68, 0x1d, 0xa6, 0x44, 0x3f, 0x45, 0x7d, 0x49, 0x4e, 0xf8, 0xce,
-	0x1c, 0xa4, 0xa7, 0x32, 0x69, 0x74, 0x5f, 0xe4, 0x7f, 0x19, 0x85, 0xb7, 0x52, 0x44, 0xa5, 0xf9,
-	0x2e, 0xe9, 0xcd, 0x7c, 0x57, 0x1d, 0x46, 0xa9, 0xb3, 0x61, 0x8a, 0x56, 0x07, 0x77, 0xbe, 0x54,
-	0x2b, 0x4a, 0x7b, 0x7e, 0x19, 0x68, 0xfc, 0x44, 0x1d, 0x7d, 0x83, 0x13, 0xf5, 0x7d, 0x98, 0x66,
-	0x27, 0x84, 0xaa, 0xb9, 0x04, 0xfb, 0x44, 0xe7, 0x8d, 0x9c, 0x02, 0x83, 0xae, 0x32, 0x60, 0x70,
-	0x58, 0x71, 0x34, 0x76, 0x76, 0x8e, 0xb1, 0xc3, 0x8a, 0xc1, 0x58, 0xc1, 0xa1, 0x12, 0x69, 0xea,
-	0x8c, 0xb3, 0x0b, 0x9b, 0xe2, 0x1d, 0x6d, 0x86, 0x37, 0xa1, 0xf2, 0x54, 0xd7, 0xa5, 0x7e, 0xba,
-	0x76, 0x0d, 0xbf, 0x4b, 0xe9, 0xc2, 0x6b, 0x51, 0x5b, 0x30, 0xed, 0x12, 0xbf, 0xed, 0x5a, 0x61,
-	0x09, 0x6c, 0x62, 0xe0, 0x12, 0x58, 0x81, 0x51, 0x72, 0x90, 0xfc, 0xef, 0x23, 0x00, 0x5d, 0x2f,
-	0x76, 0xfe, 0xad, 0xd6, 0xe0, 0x58, 0xa2, 0x3e, 0x34, 0xd7, 0xa7, 0x85, 0xc0, 0x5b, 0x32, 0x81,
-	0x2e, 0x91, 0x2b, 0x64, 0x01, 0x69, 0xcc, 0xa8, 0x23, 0x09, 0xa3, 0x9e, 0xdb, 0x1e, 0xd8, 0x83,
-	0x49, 0x76, 0x4f, 0x8c, 0x65, 0xe1, 0xec, 0x14, 0xbd, 0xdb, 0x4f, 0xdd, 0x3a, 0xf6, 0xb5, 0xa3,
-	0x40, 0x67, 0x76, 0x49, 0x80, 0x66, 0xe2, 0x60, 0x87, 0xcf, 0xd1, 0x9d, 0xc5, 0x02, 0x0c, 0xbe,
-	0x69, 0xc4, 0xce, 0x62, 0xc0, 0xc8, 0xd6, 0x18, 0x7f, 0xb3, 0xad, 0x21, 0xff, 0xab, 0x04, 0x97,
-	0x9f, 0x1e, 0x5b, 0x44, 0xef, 0xf6, 0xdb, 0xc2, 0x08, 0x64, 0x2f, 0x72, 0x0f, 0x89, 0xdd, 0xf4,
-	0x96, 0x06, 0x5b, 0x14, 0xc1, 0x8b, 0xae, 0x75, 0xf7, 0xf2, 0x11, 0xbb, 0x15, 0x9e, 0xec, 0xbd,
-	0xe5, 0xde, 0xac, 0xf7, 0x26, 0x1f, 0x42, 0xb9, 0x77, 0x02, 0xfc, 0xe0, 0x3d, 0xcf, 0xd6, 0xa3,
-	0xbc, 0x0f, 0x65, 0x9a, 0x16, 0x8a, 0x64, 0xae, 0x7e, 0x12, 0xf6, 0x59, 0x62, 0x85, 0xc3, 0xdc,
-	0x70, 0x85, 0x43, 0x59, 0x87, 0x2b, 0x29, 0x7c, 0x33, 0x33, 0x4f, 0xe9, 0x6c, 0x99, 0xe7, 0xdf,
-	0xe4, 0xe0, 0x46, 0x37, 0x85, 0xf7, 0xc2, 0x5e, 0xcb, 0x6f, 0xa7, 0xbf, 0x85, 0xbe, 0x80, 0xb1,
-	0x48, 0x2f, 0x61, 0x3a, 0xed, 0x66, 0x59, 0x3f, 0x6d, 0xaa, 0xac, 0xad, 0xa0, 0x70, 0x46, 0xf2,
-	0xd7, 0x30, 0xc6, 0x3b, 0x16, 0x73, 0x80, 0x36, 0xb6, 0xb6, 0xf7, 0xd6, 0x15, 0xf5, 0xd9, 0xce,
-	0x6e, 0x63, 0x7d, 0x75, 0x6b, 0x63, 0x6b, 0x7d, 0xad, 0x74, 0x01, 0xdd, 0x81, 0x9b, 0x1c, 0x5e,
-	0xdb, 0xde, 0x56, 0x6b, 0xab, 0x7b, 0x5b, 0xfb, 0xeb, 0xea, 0xf3, 0xad, 0xbd, 0x4d, 0x75, 0xe7,
-	0xe9, 0xce, 0x57, 0xeb, 0xca, 0x53, 0xb5, 0x5e, 0xdb, 0xae, 0xed, 0xac, 0xae, 0xef, 0x96, 0x24,
-	0x34, 0x0d, 0xd0, 0x45, 0x2e, 0xe5, 0x64, 0x02, 0xef, 0x9c, 0xa2, 0x11, 0x5f, 0x8e, 0xdf, 0x03,
-	0xa0, 0x37, 0x28, 0x58, 0xf9, 0x5f, 0x1a, 0xb4, 0xfc, 0x3f, 0xd1, 0x11, 0x8f, 0xf2, 0x5f, 0xe7,
-	0xe0, 0xbd, 0x44, 0x3d, 0x24, 0x7d, 0x2d, 0x9e, 0x85, 0x16, 0x94, 0xa8, 0x05, 0x3f, 0xef, 0xb5,
-	0xe0, 0x20, 0x7c, 0x12, 0x56, 0xec, 0x5d, 0xe2, 0xdc, 0xd9, 0xbb, 0x5d, 0xfd, 0xd6, 0xe3, 0x12,
-	0x94, 0x38, 0x7c, 0x75, 0xbb, 0xb6, 0xf5, 0xa4, 0x56, 0xdf, 0x5e, 0x2f, 0x49, 0xe8, 0x2a, 0x94,
-	0x39, 0x74, 0xe7, 0xe9, 0x9e, 0xfa, 0xc3, 0xf5, 0xbd, 0xc8, 0x68, 0x4e, 0xfe, 0x53, 0x09, 0xde,
-	0xef, 0x33, 0xaf, 0xf3, 0x5a, 0x0b, 0x74, 0x15, 0x26, 0xe8, 0x31, 0x1b, 0xc4, 0x41, 0xbc, 0x1f,
-	0xd0, 0x05, 0xac, 0xfc, 0xed, 0x65, 0x98, 0x0c, 0xd0, 0x76, 0x89, 0xdb, 0x31, 0x68, 0x27, 0x69,
-	0x8c, 0x65, 0x45, 0xe8, 0x7a, 0x4a, 0xe8, 0x16, 0xcd, 0xdd, 0x2a, 0x37, 0xb2, 0x11, 0xb8, 0xf2,
-	0x2a, 0x4c, 0x45, 0x9b, 0x29, 0xe8, 0xfd, 0x2c, 0x8a, 0x58, 0x13, 0xa6, 0xf2, 0x41, 0x3f, 0x34,
-	0xc6, 0x7e, 0x49, 0x42, 0x8f, 0xe0, 0x22, 0x8d, 0x46, 0xd1, 0x7c, 0x2f, 0x49, 0xb4, 0x31, 0x52,
-	0xb9, 0x9e, 0x39, 0x1e, 0xf2, 0x22, 0x30, 0x1d, 0x8f, 0x6c, 0xd1, 0xcd, 0x0c, 0xa2, 0x64, 0xaf,
-	0xa1, 0xb2, 0xd0, 0x1f, 0x31, 0x14, 0xf3, 0x04, 0xc6, 0x58, 0xdd, 0x2d, 0xcd, 0xc0, 0xb1, 0xc2,
-	0x69, 0x9a, 0x81, 0xe3, 0x25, 0xbb, 0x25, 0x09, 0x99, 0x30, 0xd3, 0x73, 0xae, 0xa2, 0xdb, 0x19,
-	0x84, 0x29, 0x87, 0x7a, 0xe5, 0xce, 0x40, 0xb8, 0x61, 0x81, 0xbc, 0x10, 0x2b, 0xc0, 0xa1, 0x94,
-	0xa5, 0x4a, 0x2b, 0xfd, 0x55, 0x6e, 0xf6, 0xc5, 0xe3, 0x12, 0xf6, 0x60, 0x22, 0xac, 0x86, 0x21,
-	0xb9, 0x97, 0x2a, 0x59, 0xe2, 0xab, 0xbc, 0x7b, 0x2a, 0x4e, 0x57, 0xef, 0x58, 0xf9, 0x2c, 0x4d,
-	0xef, 0xb4, 0xba, 0x5b, 0x9a, 0xde, 0xe9, 0x75, 0x38, 0x0d, 0xa6, 0xe3, 0x57, 0x1d, 0xd2, 0x76,
-	0x4f, 0xea, 0x7d, 0x8b, 0xb4, 0xdd, 0x93, 0x71, 0x6b, 0xe2, 0x0b, 0xc8, 0x8b, 0xcb, 0x0a, 0x28,
-	0x25, 0x1b, 0x4c, 0xdc, 0x8b, 0xa8, 0xc8, 0xa7, 0xa1, 0x74, 0xf5, 0x8e, 0x5f, 0x4b, 0x48, 0xd3,
-	0x3b, 0xf5, 0x2e, 0x44, 0x9a, 0xde, 0x19, 0x37, 0x1c, 0x0c, 0x28, 0x25, 0xaf, 0x0c, 0xa0, 0x5b,
-	0xbd, 0xd4, 0x19, 0x77, 0x17, 0x2a, 0xb7, 0x07, 0x41, 0xe5, 0xa2, 0x76, 0x21, 0x2f, 0xba, 0xf3,
-	0x69, 0x26, 0x4a, 0x5c, 0x31, 0x48, 0x33, 0x51, 0xb2, 0xb9, 0xbf, 0x24, 0x05, 0xfa, 0x27, 0x8b,
-	0x8e, 0x69, 0xfa, 0x67, 0x94, 0x4b, 0xd3, 0xf4, 0xcf, 0xac, 0x61, 0x1a, 0x50, 0x4a, 0x96, 0xf7,
-	0xd2, 0x44, 0x65, 0x14, 0x26, 0xd3, 0x44, 0x65, 0x56, 0x0b, 0x09, 0x4c, 0xc7, 0x4b, 0x7c, 0x69,
-	0x4b, 0x9f, 0x5a, 0x1d, 0x4c, 0x5b, 0xfa, 0xf4, 0x6a, 0xe1, 0x92, 0x84, 0x0e, 0xa0, 0x98, 0x28,
-	0xb8, 0xa1, 0xb4, 0xf3, 0x32, 0xb5, 0x3e, 0x58, 0xb9, 0x35, 0x00, 0x26, 0x9f, 0xce, 0x6b, 0x98,
-	0x4d, 0x2d, 0xa8, 0xa0, 0x6a, 0xdf, 0xba, 0x49, 0xac, 0xa0, 0x57, 0x59, 0x1c, 0x18, 0x9f, 0x4b,
-	0x3e, 0xea, 0x2d, 0xb6, 0x2d, 0xf4, 0xaf, 0xd5, 0x64, 0xcf, 0x30, 0xa3, 0xdc, 0xb4, 0x24, 0xa1,
-	0x97, 0x50, 0x4a, 0xa6, 0x01, 0x69, 0xbb, 0x23, 0x23, 0xd7, 0x49, 0xdb, 0x1d, 0x59, 0x59, 0xc5,
-	0x92, 0x84, 0x6c, 0x40, 0xbd, 0x37, 0xd0, 0xd0, 0x9d, 0x21, 0x2e, 0xd4, 0x57, 0x3e, 0x1c, 0x0c,
-	0x99, 0xdb, 0x71, 0x07, 0xc6, 0x79, 0xeb, 0x13, 0xdd, 0xc8, 0xec, 0x8a, 0x0a, 0xd6, 0xef, 0x9c,
-	0x82, 0xd1, 0x5d, 0x97, 0x44, 0x2b, 0x35, 0x6d, 0x5d, 0xd2, 0x3b, 0xdc, 0x69, 0xeb, 0x92, 0xd1,
-	0x97, 0x5d, 0x92, 0x90, 0x05, 0x33, 0x3d, 0x3f, 0xae, 0x4c, 0xf5, 0xc2, 0x19, 0xbf, 0x4d, 0x4d,
-	0xf5, 0xc2, 0x59, 0xbf, 0xd6, 0x5c, 0x92, 0xd0, 0x31, 0x5c, 0x4a, 0xfb, 0x01, 0x1f, 0xfa, 0xde,
-	0xa0, 0x3f, 0xf4, 0x63, 0x52, 0xab, 0xc3, 0xfd, 0x2e, 0x70, 0x49, 0x42, 0x7f, 0x22, 0xc1, 0x95,
-	0xcc, 0x04, 0x02, 0xad, 0x0c, 0x9f, 0xff, 0x54, 0xee, 0x0e, 0x45, 0x13, 0x2a, 0xf2, 0x97, 0x12,
-	0x5c, 0x3b, 0x35, 0x82, 0x46, 0x1f, 0x9f, 0x2d, 0x95, 0xa8, 0x7c, 0x32, 0x34, 0x5d, 0xa8, 0xd4,
-	0x2e, 0xe4, 0xc5, 0xaf, 0xb5, 0xd3, 0x9c, 0x4f, 0xe2, 0xf7, 0xed, 0x69, 0xce, 0x27, 0xf9, 0x63,
-	0xef, 0x25, 0xa9, 0xfe, 0x1b, 0xe9, 0x17, 0xdf, 0xce, 0x4b, 0xbf, 0xfa, 0x76, 0x5e, 0xfa, 0xcd,
-	0xb7, 0xf3, 0xd2, 0x5f, 0x7c, 0x37, 0x7f, 0xe1, 0x57, 0xdf, 0xcd, 0x5f, 0xf8, 0xf5, 0x77, 0xf3,
-	0x17, 0xe0, 0x92, 0x66, 0xb7, 0x7a, 0x78, 0xd4, 0x27, 0x82, 0x78, 0xbe, 0xe1, 0xda, 0xbe, 0xdd,
-	0x90, 0xbe, 0x5a, 0x3d, 0x34, 0xfc, 0xa3, 0x76, 0x33, 0xc8, 0xff, 0x17, 0x35, 0xdb, 0x6b, 0xd9,
-	0xde, 0x22, 0xfd, 0x99, 0x18, 0x71, 0x17, 0x3b, 0x2b, 0xe1, 0xa3, 0x76, 0x84, 0x0d, 0xcb, 0x5b,
-	0x4c, 0xfe, 0x47, 0x88, 0xfb, 0xc1, 0xdf, 0xce, 0xf2, 0xdf, 0xe5, 0x46, 0x1a, 0xfb, 0x5f, 0xfe,
-	0x53, 0xae, 0xd4, 0x10, 0xa2, 0x02, 0x09, 0xd5, 0xfd, 0xe5, 0x7f, 0xeb, 0x82, 0x5e, 0x04, 0xa0,
-	0x17, 0xfb, 0xcb, 0xdf, 0xe6, 0xae, 0x26, 0x41, 0x2f, 0x1e, 0x36, 0xea, 0x22, 0x9a, 0xfc, 0xaf,
-	0x1c, 0x12, 0xc3, 0xf7, 0xee, 0x05, 0xe3, 0xf7, 0xee, 0xed, 0x2f, 0x37, 0xc7, 0xe8, 0x2f, 0xcf,
-	0xef, 0xfe, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x6f, 0x46, 0x34, 0x9f, 0x93, 0x42, 0x00, 0x00,
+	0x08, 0x90, 0x7b, 0x4e, 0x39, 0x24, 0x60, 0x7d, 0xd8, 0x24, 0x9b, 0x54, 0x77, 0xcb, 0xda, 0x05,
+	0x72, 0x12, 0xf9, 0xea, 0xfd, 0xea, 0x55, 0xb1, 0xde, 0xaf, 0x5a, 0xf0, 0xb6, 0x43, 0xac, 0x76,
+	0xab, 0xe9, 0xe2, 0xc5, 0x8e, 0x41, 0x8e, 0x17, 0x3b, 0xcb, 0xf4, 0x6f, 0xd5, 0x71, 0x6d, 0xdf,
+	0x46, 0x25, 0x31, 0x58, 0xa5, 0xc0, 0xce, 0x72, 0xe5, 0xca, 0xa1, 0x6d, 0x1f, 0x9a, 0x64, 0x91,
+	0x8e, 0x37, 0xdb, 0x07, 0x8b, 0xd8, 0x3a, 0x61, 0xc8, 0x95, 0xf9, 0x90, 0x93, 0x66, 0xbb, 0x64,
+	0x11, 0x3b, 0x4e, 0xc0, 0x0d, 0x3b, 0x0e, 0x1f, 0x97, 0x13, 0xe3, 0x9e, 0x47, 0x7c, 0x8a, 0x11,
+	0x3c, 0x70, 0x9c, 0xa5, 0x38, 0x8e, 0x66, 0xb7, 0x1c, 0xdb, 0x22, 0x96, 0xbf, 0x88, 0xdb, 0x9a,
+	0x6f, 0xd8, 0x16, 0xc5, 0x67, 0x8f, 0x9c, 0x62, 0x21, 0x8b, 0x42, 0x27, 0xaf, 0x03, 0x6c, 0x9d,
+	0xbc, 0xee, 0x87, 0x79, 0x40, 0x48, 0x80, 0x79, 0x40, 0x48, 0x3f, 0x4c, 0xa3, 0xa9, 0x05, 0x98,
+	0x46, 0x53, 0xeb, 0x87, 0xe9, 0x69, 0x74, 0x6e, 0x9e, 0x26, 0x66, 0xf6, 0x20, 0x13, 0xf3, 0xc8,
+	0x20, 0xa6, 0x4e, 0x74, 0xd5, 0xb1, 0x6d, 0x93, 0xd2, 0x44, 0x01, 0x9c, 0xfa, 0xc3, 0x4c, 0x6a,
+	0x1f, 0xbf, 0xa4, 0xda, 0xd3, 0x07, 0x8e, 0x7d, 0x3d, 0x8e, 0xfd, 0x92, 0x9c, 0x78, 0x01, 0x4a,
+	0xf0, 0x37, 0x7d, 0xad, 0xac, 0x76, 0x2b, 0x40, 0xb0, 0xda, 0x2d, 0x3e, 0x5e, 0x8d, 0x8f, 0xfb,
+	0x2e, 0xb6, 0x3c, 0x1c, 0xae, 0x40, 0xe4, 0x95, 0xe3, 0xbf, 0x97, 0xc0, 0x7f, 0x7d, 0x84, 0xbd,
+	0x23, 0x8a, 0x4a, 0x9f, 0x7a, 0xf5, 0x72, 0x4f, 0x1c, 0xdf, 0x5e, 0xf4, 0x99, 0x95, 0x7c, 0x61,
+	0x25, 0xf9, 0x67, 0x39, 0x28, 0xd6, 0xd8, 0xfa, 0x7a, 0x0a, 0x79, 0xd5, 0x26, 0x9e, 0x8f, 0x1e,
+	0xc1, 0x34, 0xd6, 0x34, 0xbb, 0x6d, 0xf9, 0xea, 0x81, 0x61, 0xfa, 0xc4, 0x2d, 0x4b, 0xd7, 0xa5,
+	0x85, 0xc9, 0x95, 0x77, 0x43, 0x25, 0xab, 0x81, 0xd0, 0x2a, 0x9d, 0x5e, 0x67, 0xb9, 0x5a, 0xd3,
+	0x75, 0x97, 0x78, 0xde, 0x96, 0xa5, 0x93, 0xd7, 0x4a, 0x81, 0x93, 0x6e, 0x50, 0x4a, 0x74, 0x0b,
+	0x4a, 0x86, 0xa5, 0x99, 0x6d, 0x9d, 0xa8, 0x86, 0x15, 0xcc, 0xa0, 0x43, 0xca, 0xb9, 0xeb, 0xd2,
+	0x42, 0x5e, 0x29, 0x72, 0xf8, 0x16, 0x07, 0xa3, 0x0f, 0x01, 0xbd, 0x6a, 0x13, 0xf7, 0x44, 0x35,
+	0xb1, 0x4f, 0x3c, 0x5f, 0xf5, 0x7c, 0xec, 0x93, 0xf2, 0x08, 0x45, 0x2e, 0xd1, 0x91, 0x6d, 0x3a,
+	0xb0, 0x1b, 0xc0, 0xd1, 0x8f, 0x00, 0xf1, 0x7d, 0xa9, 0x1a, 0xba, 0x27, 0x14, 0x1d, 0xbd, 0x3e,
+	0xb2, 0x30, 0xb9, 0xf2, 0xbd, 0x84, 0xa2, 0xe1, 0xea, 0x55, 0xc5, 0x56, 0x0e, 0xb4, 0x66, 0x8f,
+	0x5b, 0xba, 0x52, 0xc2, 0xe2, 0xd1, 0x63, 0x5a, 0xcb, 0xdf, 0xe4, 0xa0, 0xd4, 0xb5, 0x8a, 0xe7,
+	0xd8, 0x96, 0x47, 0xd0, 0xe7, 0x90, 0x33, 0x74, 0x6e, 0x8a, 0x21, 0x25, 0xe4, 0x0c, 0x1d, 0x55,
+	0x61, 0x9c, 0x8f, 0x51, 0x03, 0x4c, 0xae, 0x5c, 0xaa, 0xb2, 0x4f, 0xbb, 0x2a, 0x3e, 0xed, 0x6a,
+	0xcd, 0x3a, 0x51, 0x04, 0x12, 0xda, 0x80, 0x09, 0xc7, 0xf6, 0x0c, 0xaa, 0x43, 0x79, 0x84, 0xce,
+	0x6b, 0x21, 0x53, 0x6a, 0xf0, 0xd1, 0x75, 0x96, 0xab, 0x0d, 0x4e, 0xa0, 0x74, 0x49, 0xd1, 0x06,
+	0x4c, 0x5a, 0xb6, 0x4f, 0x54, 0x97, 0x68, 0xb6, 0xab, 0x97, 0x47, 0xa9, 0xec, 0xf7, 0xab, 0xc9,
+	0x83, 0xa6, 0xba, 0xeb, 0x10, 0x4b, 0xc7, 0x4d, 0x93, 0xec, 0xd8, 0x3e, 0x51, 0x28, 0xb2, 0x02,
+	0x56, 0xf8, 0x8c, 0xde, 0x86, 0x09, 0xd3, 0xd6, 0xb0, 0xa9, 0x7a, 0xe4, 0x55, 0xf9, 0xe2, 0x75,
+	0x69, 0x61, 0x54, 0xc9, 0x53, 0xc0, 0x2e, 0x79, 0x25, 0xfb, 0x50, 0xae, 0xb5, 0xfd, 0x23, 0xdb,
+	0x35, 0xfe, 0x88, 0xd4, 0x2c, 0xbd, 0xde, 0x36, 0x4c, 0x5d, 0x6c, 0xa7, 0x2f, 0xa1, 0x14, 0xd9,
+	0xbf, 0xaa, 0x63, 0x62, 0x2b, 0xc3, 0x8a, 0xd1, 0x6d, 0xde, 0x59, 0xae, 0xee, 0x75, 0x5f, 0x1b,
+	0x26, 0xb6, 0x94, 0xa2, 0x1f, 0x07, 0xc8, 0xdf, 0xe5, 0xe0, 0x4a, 0x8a, 0x58, 0xbe, 0x5e, 0x4d,
+	0x98, 0x6e, 0x06, 0x00, 0xd5, 0x71, 0xed, 0xc3, 0x60, 0x83, 0x72, 0xa9, 0x9f, 0xf5, 0xce, 0x3d,
+	0x93, 0x49, 0x95, 0xbe, 0x35, 0x38, 0x83, 0xcd, 0x0b, 0x4a, 0xa1, 0x19, 0x05, 0x20, 0x05, 0xf2,
+	0xc1, 0x22, 0x98, 0xc4, 0x27, 0x7c, 0x55, 0x3f, 0x1a, 0x86, 0xfb, 0x2a, 0xa7, 0xdd, 0xbc, 0xa0,
+	0x84, 0x7c, 0x2a, 0x77, 0xa0, 0x10, 0x93, 0x8a, 0x2a, 0x90, 0x8f, 0x4d, 0x21, 0xa7, 0x84, 0xef,
+	0x95, 0xe7, 0x90, 0x17, 0x4c, 0xd0, 0x63, 0x98, 0x8c, 0x58, 0x88, 0xcf, 0xf6, 0xd6, 0xc0, 0x36,
+	0x56, 0xa2, 0xd4, 0xf5, 0x3c, 0x8c, 0x05, 0x1f, 0x60, 0xdb, 0x93, 0x7f, 0x26, 0xc1, 0xdb, 0x75,
+	0xd7, 0xc6, 0xba, 0x86, 0x3d, 0x3f, 0x8a, 0xcf, 0xd7, 0xf7, 0x3c, 0xc5, 0xa2, 0x9b, 0x50, 0xc4,
+	0xc7, 0xd8, 0xf0, 0x55, 0x9d, 0xf8, 0xa4, 0xfb, 0xb5, 0xe4, 0x95, 0x69, 0x0a, 0x5e, 0x13, 0x50,
+	0xf9, 0x9b, 0x11, 0xb8, 0x9a, 0xae, 0x15, 0x5f, 0x7e, 0x0b, 0x66, 0x9a, 0x62, 0x5c, 0xf5, 0xda,
+	0x9a, 0xd6, 0xdd, 0x01, 0x3f, 0xe8, 0x5d, 0xa3, 0xd3, 0x58, 0x75, 0x07, 0x77, 0x19, 0x9b, 0xcd,
+	0x0b, 0x4a, 0xa9, 0x99, 0x80, 0xa1, 0x2f, 0x61, 0x42, 0xb3, 0xad, 0x03, 0xc3, 0x6d, 0x11, 0x9d,
+	0xef, 0x85, 0x4f, 0x87, 0x94, 0xb3, 0x2a, 0xe8, 0x37, 0x2f, 0x28, 0x5d, 0x66, 0x95, 0x47, 0x50,
+	0x4a, 0x6a, 0x80, 0x3e, 0x8e, 0x1c, 0x46, 0x1f, 0x24, 0x6d, 0xcd, 0x5c, 0x40, 0xdc, 0xcc, 0xec,
+	0x14, 0xaa, 0x58, 0x30, 0x11, 0x4a, 0x39, 0x2b, 0x93, 0xe0, 0x50, 0x0f, 0x97, 0x47, 0x3d, 0x22,
+	0xc6, 0xe1, 0x91, 0x4f, 0x67, 0x3c, 0xaa, 0x14, 0x43, 0xf8, 0x26, 0x05, 0x47, 0xb6, 0xd1, 0x7f,
+	0xce, 0xc3, 0x95, 0xc4, 0x17, 0x6d, 0x11, 0x57, 0x6c, 0xa2, 0x77, 0xa1, 0x40, 0x5e, 0x3b, 0x86,
+	0x7b, 0x22, 0xf8, 0x49, 0x94, 0xdf, 0x14, 0x03, 0x32, 0x66, 0xe8, 0x07, 0x30, 0xda, 0x22, 0x2d,
+	0x9b, 0xfa, 0x84, 0xc9, 0x95, 0x3b, 0xa7, 0x6f, 0xb1, 0x27, 0xa4, 0x65, 0x37, 0x4c, 0x6c, 0x58,
+	0x3e, 0x79, 0xed, 0x2b, 0x94, 0x10, 0xdd, 0x87, 0x31, 0xcf, 0x6e, 0xbb, 0x1a, 0xe1, 0xc7, 0xe0,
+	0x40, 0x1e, 0x8d, 0x93, 0xa0, 0x6d, 0x18, 0xb7, 0xdb, 0xbe, 0xd3, 0xf6, 0xbd, 0xf2, 0x25, 0x7a,
+	0x1c, 0xaf, 0xf4, 0x2e, 0x6f, 0xe6, 0x04, 0xab, 0x4f, 0x29, 0xa9, 0x22, 0x58, 0xa0, 0x2d, 0x18,
+	0xf3, 0x82, 0x13, 0xd7, 0x2b, 0xcf, 0x52, 0x66, 0xcb, 0xc3, 0x30, 0xa3, 0x67, 0xb5, 0xc2, 0x19,
+	0xa0, 0x0d, 0xb8, 0xe8, 0x1d, 0x63, 0xc7, 0x2b, 0xcf, 0x53, 0x4e, 0x4b, 0x43, 0x71, 0x3a, 0xc6,
+	0x8e, 0xc2, 0xc8, 0xd1, 0x3e, 0x4c, 0x06, 0x0f, 0xaa, 0x66, 0x62, 0xa3, 0xe5, 0x95, 0xaf, 0x51,
+	0x6e, 0xdf, 0x1f, 0x96, 0xdb, 0x6a, 0x40, 0xad, 0x80, 0x27, 0x1e, 0x29, 0x5f, 0x9d, 0x98, 0xe4,
+	0x10, 0x33, 0x5f, 0xb6, 0x40, 0xf9, 0x7e, 0x34, 0x0c, 0xdf, 0x35, 0x46, 0x4e, 0x94, 0x28, 0x23,
+	0xf4, 0x02, 0x0a, 0x6d, 0x2b, 0xca, 0x79, 0x85, 0x72, 0xfe, 0x78, 0x18, 0xce, 0xcf, 0x04, 0x03,
+	0xa2, 0xc4, 0x99, 0x21, 0x13, 0xde, 0x8a, 0x02, 0x84, 0x55, 0xee, 0x52, 0x19, 0xf7, 0xcf, 0x26,
+	0x83, 0xd9, 0x06, 0x45, 0xf9, 0x72, 0x1b, 0xed, 0xc1, 0x8c, 0xd1, 0xd4, 0x54, 0x97, 0x98, 0xf8,
+	0x44, 0x65, 0x5c, 0xbc, 0xf2, 0x83, 0x3e, 0x5e, 0x3f, 0x08, 0x8b, 0x3b, 0xcb, 0xd5, 0xad, 0xa6,
+	0xa6, 0x04, 0x74, 0x4a, 0xd1, 0xe0, 0x4f, 0x35, 0x4d, 0x58, 0x68, 0xc6, 0xd0, 0xbc, 0x95, 0x25,
+	0xf5, 0xd8, 0xf0, 0x8f, 0x74, 0x17, 0x1f, 0x63, 0xd3, 0x2b, 0x7f, 0x4e, 0xb9, 0x2e, 0xf6, 0xe5,
+	0x1a, 0x10, 0x3e, 0x0f, 0xe9, 0x94, 0x92, 0x11, 0x07, 0x78, 0x48, 0x85, 0x69, 0x11, 0x66, 0xa8,
+	0xb6, 0x43, 0x2c, 0xaf, 0xbc, 0x41, 0x59, 0x7f, 0x3a, 0x8c, 0x71, 0x44, 0xc8, 0xf2, 0xd4, 0x21,
+	0x96, 0x52, 0x70, 0x22, 0x6f, 0x1e, 0x6a, 0x42, 0x31, 0x14, 0xa0, 0x99, 0xb6, 0x47, 0xbc, 0xf2,
+	0x43, 0x2a, 0xe1, 0xb3, 0xb3, 0x48, 0x58, 0x0d, 0x38, 0x28, 0xa1, 0xca, 0xf4, 0xd5, 0x43, 0x2f,
+	0x01, 0x85, 0x32, 0x84, 0x95, 0xbc, 0xf2, 0x26, 0x15, 0xf3, 0xe0, 0x2c, 0x62, 0x84, 0x85, 0x94,
+	0x19, 0x27, 0x01, 0xf1, 0xd0, 0x4f, 0x25, 0x98, 0xd7, 0xdb, 0xbe, 0x76, 0xa4, 0x8a, 0xd8, 0xd5,
+	0xd3, 0x8e, 0x88, 0xde, 0x36, 0x49, 0xb8, 0xe6, 0x5b, 0x54, 0xf2, 0xc6, 0x30, 0x92, 0xd9, 0x6a,
+	0xaf, 0x05, 0x7c, 0x79, 0xc8, 0xb9, 0xcb, 0xb9, 0x2a, 0x6f, 0xeb, 0x29, 0x50, 0xb1, 0x3b, 0x7e,
+	0x0c, 0x57, 0xe2, 0xca, 0x10, 0x4b, 0x0f, 0xf5, 0x78, 0x44, 0xf5, 0xa8, 0xbd, 0x99, 0x1e, 0xeb,
+	0x96, 0xae, 0xcc, 0xe9, 0x71, 0x80, 0x90, 0xde, 0x6b, 0x0b, 0x61, 0xfe, 0x50, 0x87, 0xc7, 0xe7,
+	0x61, 0x8b, 0x70, 0x3d, 0x62, 0xb6, 0x10, 0x50, 0xa1, 0xcd, 0x1a, 0xe4, 0x71, 0xdb, 0xb7, 0xd5,
+	0x03, 0x42, 0xca, 0x3a, 0xf5, 0x0d, 0x37, 0x33, 0x3f, 0x90, 0x20, 0x6f, 0xed, 0x2c, 0x57, 0x37,
+	0x08, 0xd9, 0x33, 0x88, 0xbb, 0x79, 0x21, 0x88, 0xd9, 0x7d, 0x7b, 0x83, 0x10, 0xb4, 0x06, 0xd0,
+	0xc2, 0x56, 0x1b, 0x9b, 0x94, 0x0f, 0x49, 0xf5, 0x31, 0x69, 0x7c, 0x02, 0x7f, 0xcf, 0x08, 0x03,
+	0x2e, 0xef, 0xc1, 0x24, 0x71, 0x6c, 0xed, 0x48, 0x35, 0x02, 0xff, 0x53, 0xfe, 0x05, 0x75, 0x85,
+	0xf5, 0x5c, 0x59, 0x52, 0x80, 0xc2, 0xa9, 0x5b, 0x42, 0x0f, 0xe0, 0x22, 0x7d, 0x2b, 0xff, 0x52,
+	0x4a, 0x86, 0xf4, 0x09, 0x39, 0x41, 0x4e, 0xdc, 0x59, 0xae, 0xae, 0x07, 0xd8, 0x0a, 0x23, 0xaa,
+	0x1c, 0xc3, 0x18, 0xf3, 0x48, 0xe8, 0x2e, 0x5c, 0xec, 0x60, 0xb3, 0x4d, 0x78, 0x1c, 0xf0, 0x4e,
+	0x82, 0x0d, 0x2b, 0x16, 0x74, 0x96, 0xab, 0xfb, 0x01, 0x92, 0xc2, 0x70, 0xd1, 0xa7, 0x30, 0x8e,
+	0x99, 0x8f, 0xe4, 0xa1, 0xce, 0xfc, 0xe9, 0x9e, 0x54, 0x11, 0xe8, 0x95, 0x0e, 0x5c, 0xa4, 0xde,
+	0xeb, 0x77, 0x2d, 0xf7, 0x7f, 0x24, 0x18, 0x0d, 0xdc, 0xd3, 0xd9, 0xe4, 0xd6, 0x61, 0xca, 0xc7,
+	0xee, 0x21, 0xf1, 0x55, 0x3a, 0xce, 0x85, 0x5f, 0xcb, 0xa2, 0xad, 0x05, 0x0f, 0x5b, 0xba, 0x32,
+	0xc9, 0x88, 0xe8, 0x2b, 0xfa, 0x3e, 0x8c, 0x04, 0xbb, 0x62, 0x64, 0xe0, 0x5d, 0xa1, 0x04, 0xf8,
+	0x68, 0x15, 0x0a, 0xd4, 0xf5, 0xa8, 0x62, 0xe2, 0xa3, 0x03, 0x4d, 0x7c, 0x8a, 0x12, 0xf1, 0xb7,
+	0xca, 0xd7, 0x30, 0x11, 0xfa, 0x66, 0xd4, 0x80, 0x22, 0xf3, 0xf3, 0x76, 0xab, 0x65, 0xf8, 0x2d,
+	0x62, 0xf9, 0xdc, 0x16, 0xd1, 0x2d, 0x4f, 0xeb, 0x05, 0x55, 0x9f, 0x6d, 0x1d, 0x9a, 0x72, 0xaf,
+	0x86, 0xe8, 0xca, 0x34, 0xf5, 0xee, 0xe1, 0x7b, 0xe5, 0xcf, 0x24, 0xc8, 0x0b, 0x1f, 0x8d, 0x3e,
+	0x82, 0x31, 0xdc, 0xb2, 0xdb, 0x21, 0xd7, 0xab, 0x09, 0x4d, 0xad, 0x76, 0x8b, 0x2a, 0x4a, 0x71,
+	0x14, 0x8e, 0x8b, 0x1e, 0xc2, 0x84, 0x8b, 0x7d, 0xa2, 0xea, 0xd8, 0xc7, 0xdc, 0x46, 0xb7, 0xb3,
+	0x77, 0x34, 0xad, 0xbd, 0x74, 0x96, 0xab, 0x0a, 0xf6, 0xc9, 0x1a, 0xf6, 0xb1, 0x92, 0x77, 0xf9,
+	0x53, 0xe5, 0x27, 0x12, 0x40, 0xd7, 0xe3, 0x9e, 0x6d, 0xb9, 0x63, 0xca, 0xe4, 0xde, 0x40, 0x99,
+	0x5f, 0xe7, 0xa0, 0x98, 0x70, 0xff, 0xe8, 0x0b, 0x40, 0x1d, 0x6c, 0x1a, 0x3a, 0xf6, 0x6d, 0x57,
+	0x35, 0x74, 0x62, 0xf9, 0x86, 0x7f, 0xc2, 0xd5, 0x93, 0x33, 0x56, 0x75, 0x8b, 0xa3, 0x3d, 0x26,
+	0x27, 0xca, 0x4c, 0x48, 0x2d, 0xa0, 0xa8, 0x0a, 0x33, 0x9e, 0x8f, 0x5d, 0x5f, 0x8d, 0x9e, 0x1b,
+	0xb9, 0xf0, 0xd8, 0x28, 0xd2, 0xc1, 0xf5, 0xee, 0xd9, 0xb1, 0x0a, 0xe3, 0x0e, 0xb1, 0xb0, 0xe9,
+	0x9f, 0x70, 0x53, 0xdf, 0xea, 0x3f, 0xbb, 0x06, 0x23, 0x50, 0x04, 0x25, 0x7a, 0x08, 0xa5, 0xb6,
+	0xd5, 0xb4, 0x2d, 0xdd, 0xb0, 0x0e, 0x55, 0xbe, 0xe2, 0xa3, 0x03, 0xac, 0x78, 0x31, 0xa4, 0x62,
+	0x00, 0xf4, 0x11, 0xcc, 0x75, 0x19, 0xb1, 0x79, 0xf0, 0x24, 0x80, 0x95, 0x19, 0x2e, 0x85, 0xa3,
+	0xbb, 0xc1, 0x20, 0x4b, 0x06, 0x2a, 0x7b, 0x30, 0x15, 0x8d, 0x1d, 0x82, 0x13, 0x5c, 0x38, 0x5c,
+	0x6e, 0xcc, 0xc1, 0xcb, 0x25, 0x21, 0x65, 0xe5, 0x05, 0x14, 0x62, 0xf1, 0x42, 0x90, 0xdd, 0x86,
+	0xf1, 0x41, 0x98, 0x2c, 0xdd, 0x1e, 0x94, 0xf3, 0x96, 0xae, 0x80, 0x13, 0x3e, 0x57, 0xfe, 0x5b,
+	0x82, 0x52, 0x32, 0x4e, 0x38, 0x57, 0x09, 0x81, 0x15, 0x5c, 0xe2, 0x11, 0xb7, 0x43, 0xc4, 0x09,
+	0xd9, 0xd7, 0x0a, 0x0a, 0xc7, 0x57, 0x42, 0x4a, 0xb4, 0x03, 0x53, 0xbe, 0x8b, 0xe9, 0x7a, 0x38,
+	0xd8, 0x70, 0x33, 0x12, 0xae, 0x1e, 0x4e, 0x7b, 0x8c, 0xa6, 0x81, 0x0d, 0x97, 0x66, 0xf5, 0xe2,
+	0xa5, 0xf2, 0xc7, 0x50, 0xc9, 0x0e, 0x52, 0xd0, 0xd7, 0x41, 0x7e, 0xe0, 0x69, 0xae, 0xe1, 0x44,
+	0x16, 0xef, 0xfe, 0x20, 0x15, 0xb6, 0x28, 0xbb, 0xb5, 0x2e, 0x0b, 0x25, 0xca, 0xaf, 0x42, 0x60,
+	0x36, 0x35, 0x32, 0x41, 0xdb, 0x00, 0xdd, 0x12, 0xe2, 0xd9, 0x0a, 0x7b, 0x13, 0x61, 0xe9, 0xb0,
+	0xf2, 0xe3, 0xb4, 0x39, 0x86, 0x8b, 0x7c, 0xae, 0xb2, 0x50, 0x09, 0x46, 0x3c, 0xf2, 0x8a, 0xe7,
+	0xdc, 0xc1, 0x63, 0x1d, 0x20, 0x7f, 0x40, 0x88, 0xda, 0xb2, 0x75, 0x22, 0xab, 0x50, 0x49, 0x0b,
+	0x90, 0x78, 0x5d, 0xa4, 0x06, 0xa3, 0x67, 0x2f, 0xc1, 0x51, 0x52, 0x19, 0xc3, 0x2c, 0x77, 0x2c,
+	0xf5, 0x13, 0x96, 0x23, 0xf3, 0x2c, 0x7e, 0x13, 0x0a, 0xdc, 0x4b, 0xf1, 0x33, 0x68, 0x88, 0xc2,
+	0xf1, 0x14, 0x8e, 0xbc, 0xc9, 0x0a, 0xcc, 0x25, 0x45, 0x70, 0xfd, 0x23, 0x21, 0x80, 0x34, 0x54,
+	0x08, 0x20, 0xcf, 0x40, 0xf1, 0x39, 0x36, 0x4d, 0xea, 0x99, 0x99, 0xc2, 0x72, 0x03, 0x4a, 0x5d,
+	0x10, 0x17, 0xf0, 0x00, 0x26, 0x8e, 0x29, 0xac, 0xbb, 0x52, 0xd7, 0x32, 0x44, 0x84, 0xb4, 0xf9,
+	0x63, 0xfe, 0x24, 0x7f, 0x01, 0xb3, 0x54, 0xdf, 0xfa, 0x89, 0x90, 0xcf, 0x6d, 0x73, 0x76, 0xbd,
+	0x9b, 0x30, 0x97, 0x64, 0xc9, 0x55, 0x3d, 0x3f, 0x7b, 0x6b, 0x70, 0x79, 0xdd, 0x39, 0x22, 0x2d,
+	0xe2, 0x62, 0x33, 0xa1, 0xf8, 0xf9, 0x09, 0xd9, 0x83, 0x72, 0xaf, 0x90, 0x37, 0x5e, 0xd6, 0xbf,
+	0x97, 0xa0, 0x58, 0xc7, 0x26, 0xb6, 0x34, 0xf2, 0x5b, 0x69, 0x61, 0x3c, 0x84, 0x22, 0x8d, 0x12,
+	0x54, 0x43, 0x17, 0xcc, 0x06, 0x0c, 0xff, 0x0a, 0x98, 0x3d, 0xf0, 0xae, 0xc2, 0xcf, 0x73, 0x50,
+	0xea, 0x2a, 0x1a, 0x7e, 0x8e, 0xe3, 0x5c, 0xdc, 0x10, 0x2a, 0x52, 0xaf, 0x2e, 0xe8, 0xd0, 0x7d,
+	0x18, 0x6f, 0x32, 0xb6, 0x5c, 0xb1, 0xd3, 0x83, 0x1c, 0x46, 0xcc, 0x29, 0xd0, 0x63, 0x28, 0x0a,
+	0x4b, 0x09, 0xfb, 0x8f, 0x9c, 0x1a, 0x8a, 0x70, 0x3d, 0xf6, 0x0d, 0x72, 0xac, 0x08, 0x23, 0x73,
+	0x18, 0x5a, 0x83, 0x29, 0xce, 0x57, 0x0d, 0x52, 0x35, 0x1e, 0x0e, 0xdc, 0x38, 0x55, 0x1d, 0xca,
+	0x68, 0x92, 0x93, 0x05, 0x2f, 0x72, 0x11, 0x0a, 0xbb, 0xb4, 0x66, 0x28, 0xbe, 0xd2, 0x9f, 0x4a,
+	0x30, 0x2d, 0x20, 0xdc, 0x6c, 0x0b, 0x50, 0x3a, 0x68, 0x9b, 0xa6, 0xea, 0x9d, 0x58, 0x5a, 0xbc,
+	0x64, 0x38, 0x1d, 0xc0, 0x77, 0x4f, 0x2c, 0x8d, 0x17, 0x0d, 0xab, 0xf0, 0x96, 0x83, 0x5d, 0xdf,
+	0xc0, 0x71, 0x64, 0x76, 0x76, 0xce, 0xf0, 0xa1, 0x08, 0xfe, 0x35, 0x98, 0xd4, 0xb0, 0xaf, 0x1d,
+	0x05, 0xce, 0xaf, 0xed, 0xf0, 0xfe, 0x13, 0x08, 0xd0, 0x33, 0x47, 0x9e, 0x85, 0xb7, 0x98, 0x32,
+	0xbb, 0xbe, 0x4b, 0x70, 0x4b, 0x28, 0xf9, 0x4f, 0x12, 0x5c, 0x8a, 0xc3, 0xb9, 0xaa, 0x9f, 0xc1,
+	0x15, 0xde, 0xd1, 0x7a, 0x69, 0xd9, 0xc7, 0x96, 0xda, 0x34, 0x6d, 0xed, 0x65, 0x5c, 0xe7, 0x39,
+	0x86, 0xf0, 0x38, 0x18, 0xaf, 0x07, 0xc3, 0x5c, 0x97, 0xb4, 0x59, 0xe6, 0x86, 0x99, 0xe5, 0x48,
+	0xc6, 0x2c, 0xe5, 0xff, 0x95, 0x60, 0x6a, 0xc7, 0xf6, 0xbb, 0x5f, 0xcc, 0xbb, 0x50, 0x10, 0x8d,
+	0x3a, 0xcf, 0x09, 0x52, 0x02, 0x56, 0x76, 0x9f, 0xe2, 0xc0, 0x20, 0x67, 0xf3, 0xd1, 0x3d, 0xc8,
+	0x8b, 0x4f, 0x81, 0xef, 0x92, 0xbe, 0xdf, 0xc0, 0x38, 0xff, 0x06, 0x7a, 0x8f, 0x91, 0xd1, 0x33,
+	0x1e, 0x23, 0x68, 0x0d, 0x8a, 0x2c, 0xdc, 0x54, 0x7d, 0x9b, 0x2a, 0xab, 0x97, 0xc7, 0x06, 0x88,
+	0x3b, 0x0b, 0x8c, 0x68, 0xcf, 0xa6, 0xf9, 0xa7, 0xfc, 0xe7, 0x12, 0xcc, 0x52, 0x0b, 0x6c, 0xd8,
+	0xee, 0xbe, 0xed, 0x1b, 0xd6, 0xa1, 0x30, 0xc5, 0x6d, 0x98, 0xe9, 0xd8, 0x3e, 0x6e, 0x9a, 0x44,
+	0xc5, 0x7e, 0x7c, 0xa1, 0x8a, 0x7c, 0xa0, 0xc6, 0xa3, 0xd0, 0xde, 0x59, 0x8d, 0x9c, 0xf5, 0x70,
+	0xfc, 0x43, 0x98, 0x7e, 0x6e, 0xf8, 0x56, 0xe4, 0xe0, 0x4d, 0x6b, 0x9c, 0x8d, 0x9c, 0x4b, 0xe3,
+	0x4c, 0x85, 0x62, 0x28, 0x8b, 0xef, 0xd2, 0x6d, 0x98, 0x3a, 0x66, 0x20, 0x96, 0xf5, 0x0c, 0xd4,
+	0xc6, 0xe1, 0x4c, 0x68, 0xd2, 0x33, 0x79, 0xdc, 0x7d, 0x91, 0xff, 0x5d, 0x82, 0x39, 0x3e, 0xf8,
+	0x3b, 0x6b, 0x07, 0xa2, 0xdf, 0x07, 0x84, 0x79, 0xab, 0x8d, 0x95, 0x6c, 0x23, 0xe9, 0xdb, 0xe2,
+	0xe9, 0xbc, 0x6b, 0x51, 0x3a, 0x3a, 0x9d, 0x19, 0x9c, 0x04, 0xc9, 0xff, 0x91, 0x83, 0xcb, 0x3d,
+	0x93, 0xe2, 0xe6, 0xfb, 0x83, 0x8c, 0x66, 0xe3, 0x27, 0xbd, 0xc5, 0xab, 0x0c, 0x16, 0xfd, 0x5a,
+	0x8d, 0x8d, 0x9e, 0x56, 0xe3, 0xca, 0xe0, 0xbc, 0xff, 0x5f, 0x34, 0x1a, 0x7f, 0x3e, 0x02, 0x05,
+	0x7a, 0x6c, 0x84, 0x5f, 0x40, 0x05, 0xf2, 0xcc, 0xe3, 0x12, 0x16, 0x89, 0xe5, 0x95, 0xf0, 0x1d,
+	0x69, 0x30, 0x1f, 0x39, 0xb0, 0x34, 0xe3, 0xc0, 0xd0, 0x54, 0x9d, 0x58, 0x76, 0xcb, 0xb0, 0x78,
+	0x3b, 0x20, 0x47, 0xcb, 0x87, 0x99, 0xce, 0x70, 0x2d, 0x40, 0x56, 0xae, 0x76, 0x0f, 0x38, 0xca,
+	0x63, 0x2d, 0xca, 0x02, 0xdd, 0x83, 0x2b, 0x42, 0x48, 0xa4, 0x15, 0xe0, 0xdb, 0x2f, 0x89, 0xe5,
+	0x71, 0xd7, 0x70, 0x99, 0x23, 0xac, 0x85, 0xe3, 0x7b, 0x74, 0x18, 0x7d, 0x0a, 0x65, 0x41, 0xdb,
+	0x4d, 0x6f, 0x39, 0xe9, 0x28, 0x25, 0x9d, 0xe3, 0xe3, 0xcf, 0xc4, 0x30, 0xa7, 0xfc, 0x00, 0xc4,
+	0xe5, 0x08, 0xd5, 0x74, 0x54, 0xeb, 0xc0, 0xf7, 0x68, 0x26, 0x9c, 0x57, 0xc4, 0x11, 0xbd, 0xed,
+	0xec, 0x1c, 0xf8, 0x1e, 0x5a, 0x81, 0x59, 0x81, 0xe7, 0xb8, 0xb6, 0x63, 0x7b, 0xd8, 0x64, 0xd8,
+	0x63, 0x14, 0xfb, 0x2d, 0x3e, 0xd8, 0xe0, 0x63, 0x94, 0xa6, 0x06, 0xef, 0x08, 0x9a, 0x0e, 0x3d,
+	0xf5, 0x54, 0x97, 0x68, 0xc4, 0x70, 0x7c, 0xa1, 0xda, 0x38, 0xa5, 0xad, 0x70, 0x24, 0x71, 0x32,
+	0x52, 0x14, 0xa6, 0x9e, 0xfc, 0x43, 0x98, 0x16, 0xcb, 0xc4, 0x77, 0xff, 0x43, 0x98, 0xa6, 0xa6,
+	0x57, 0x5b, 0xc4, 0xc7, 0x91, 0xaf, 0xee, 0x7a, 0x96, 0xed, 0x9f, 0x70, 0x3c, 0xa5, 0x40, 0xe9,
+	0xc4, 0xab, 0x3c, 0x07, 0x97, 0x6a, 0x8e, 0xd3, 0xc0, 0x2e, 0x6e, 0x11, 0x9f, 0xb8, 0x61, 0x04,
+	0xf0, 0x02, 0x66, 0x13, 0x70, 0x2e, 0x79, 0x15, 0xc0, 0x09, 0xa1, 0x19, 0x11, 0x14, 0x76, 0x1c,
+	0xfa, 0x8d, 0xc7, 0x18, 0x44, 0xc8, 0x64, 0x04, 0xa5, 0x87, 0xd8, 0x6b, 0xb8, 0x46, 0x37, 0x82,
+	0x94, 0xbf, 0x91, 0x60, 0x26, 0x02, 0x0c, 0x03, 0x6e, 0x38, 0xc4, 0x9e, 0xea, 0x50, 0x68, 0xc6,
+	0xc6, 0xef, 0x29, 0xe5, 0x75, 0xd9, 0x4c, 0x1c, 0x8a, 0x47, 0xf4, 0x14, 0xa6, 0xb1, 0xe9, 0xab,
+	0x11, 0x6e, 0x6c, 0xbb, 0x0e, 0xc1, 0x6d, 0x0a, 0x9b, 0x7e, 0xf8, 0x16, 0x98, 0x6e, 0xe3, 0xc9,
+	0x5a, 0xaf, 0xe9, 0x1c, 0x98, 0x4d, 0xc0, 0xf9, 0x5c, 0x9e, 0xa7, 0x98, 0xee, 0x93, 0xec, 0x3a,
+	0x50, 0xec, 0x92, 0x54, 0x67, 0xb9, 0xba, 0xd1, 0xd2, 0x33, 0xcc, 0xf9, 0x57, 0x12, 0x5c, 0x0e,
+	0x3c, 0x6b, 0xfd, 0x24, 0x52, 0x32, 0xe4, 0x5f, 0x74, 0x03, 0x8a, 0xf4, 0x36, 0x4a, 0xa4, 0xf6,
+	0x98, 0x1b, 0xb2, 0xf6, 0x18, 0xd0, 0x77, 0xdf, 0xd3, 0x6e, 0x0c, 0x8c, 0xa4, 0xde, 0x18, 0x38,
+	0x82, 0x72, 0xaf, 0x56, 0xa1, 0xf7, 0x9b, 0xf6, 0xc4, 0xfd, 0x17, 0x35, 0x10, 0x50, 0x96, 0x86,
+	0xb9, 0x27, 0x53, 0xf0, 0xa2, 0x40, 0x6a, 0x80, 0xdd, 0x63, 0xec, 0x64, 0x18, 0x20, 0x59, 0x7c,
+	0xcd, 0xbd, 0x51, 0xf1, 0x75, 0x70, 0x03, 0x6c, 0x43, 0xb9, 0x57, 0x2b, 0x6e, 0x80, 0x25, 0x18,
+	0x0d, 0xd8, 0xf6, 0x96, 0x6c, 0xc3, 0x69, 0x1f, 0x63, 0x87, 0xcf, 0x96, 0x62, 0xca, 0x97, 0x61,
+	0xf6, 0x99, 0x45, 0x8b, 0xcc, 0x44, 0x0f, 0x06, 0xc3, 0x0d, 0xf7, 0x08, 0xe6, 0x92, 0x03, 0x67,
+	0x16, 0xf2, 0x13, 0x09, 0xe6, 0x76, 0xda, 0xa6, 0x69, 0x1c, 0x18, 0xc4, 0x8d, 0x25, 0x05, 0xe8,
+	0x21, 0x4c, 0x58, 0x62, 0x84, 0x9b, 0xf0, 0x56, 0xbf, 0x16, 0x48, 0xc8, 0x4a, 0xe9, 0xd2, 0x0e,
+	0x6e, 0xbf, 0x45, 0xb8, 0xdc, 0xa3, 0x0b, 0x9f, 0xd9, 0x25, 0xb8, 0xc8, 0xa2, 0x66, 0xe6, 0xa5,
+	0xd8, 0x8b, 0xbc, 0x0f, 0x57, 0xa3, 0x97, 0x27, 0xac, 0x03, 0xbb, 0x7e, 0xb2, 0x89, 0xbd, 0x23,
+	0x31, 0x05, 0x76, 0xff, 0x22, 0x37, 0xec, 0xfd, 0x0b, 0xf9, 0x2b, 0x98, 0x4b, 0xf0, 0x15, 0x1c,
+	0x6f, 0xc0, 0x54, 0xac, 0x80, 0xca, 0xa2, 0xd6, 0x49, 0xaf, 0x5b, 0x37, 0x45, 0xef, 0x00, 0x10,
+	0x4b, 0x8f, 0x67, 0x13, 0x13, 0xc4, 0xd2, 0x79, 0x62, 0xf0, 0xcb, 0x1c, 0x14, 0x13, 0xcc, 0xd1,
+	0x1c, 0x8c, 0xc5, 0xf8, 0xf1, 0xb7, 0xb3, 0xea, 0x9f, 0x8c, 0x1f, 0x46, 0xde, 0xe8, 0xc6, 0xd0,
+	0x3e, 0x4c, 0x3a, 0xc4, 0x0d, 0x42, 0x00, 0x7a, 0xb9, 0x70, 0x34, 0x79, 0x0b, 0xab, 0x5f, 0x28,
+	0xd9, 0xa5, 0x55, 0xa2, 0x8c, 0x50, 0x0d, 0x46, 0x69, 0x0e, 0x7b, 0x71, 0xc8, 0xd8, 0x94, 0xe6,
+	0xb3, 0x94, 0x54, 0x7e, 0x06, 0x97, 0x7b, 0xd6, 0x89, 0x6f, 0x98, 0x7b, 0x30, 0xee, 0xbf, 0x56,
+	0x0d, 0xeb, 0xc0, 0xe6, 0x5f, 0xc3, 0x8d, 0x53, 0xbb, 0x9c, 0x94, 0x76, 0xcc, 0x7f, 0x1d, 0xfc,
+	0x95, 0x7f, 0x04, 0xef, 0x64, 0x6c, 0xab, 0x73, 0x60, 0xfe, 0x1c, 0x0a, 0x3c, 0x2f, 0xe4, 0xcc,
+	0x12, 0xf7, 0x07, 0xa5, 0x33, 0xde, 0x1f, 0x94, 0xff, 0x21, 0xf8, 0x94, 0x13, 0xf9, 0xd6, 0xf9,
+	0x8a, 0x40, 0xeb, 0x30, 0x25, 0xfa, 0x29, 0xea, 0x4b, 0x72, 0xc2, 0x77, 0xe6, 0x20, 0x3d, 0x95,
+	0x49, 0xa3, 0xfb, 0x22, 0xff, 0xf3, 0x28, 0xbc, 0x95, 0x22, 0x2a, 0xcd, 0x77, 0x49, 0x6f, 0xe6,
+	0xbb, 0xea, 0x30, 0x4a, 0x9d, 0x0d, 0x53, 0xb4, 0x3a, 0xb8, 0xf3, 0xa5, 0x5a, 0x51, 0xda, 0xf3,
+	0xcb, 0x40, 0xe3, 0x27, 0xea, 0xe8, 0x1b, 0x9c, 0xa8, 0xef, 0xc3, 0x34, 0x3b, 0x21, 0x54, 0xcd,
+	0x25, 0xd8, 0x27, 0x3a, 0x6f, 0xe4, 0x14, 0x18, 0x74, 0x95, 0x01, 0x83, 0xc3, 0x8a, 0xa3, 0xb1,
+	0xb3, 0x73, 0x8c, 0x1d, 0x56, 0x0c, 0xc6, 0x0a, 0x0e, 0x95, 0x48, 0x53, 0x67, 0x9c, 0xdd, 0x39,
+	0x15, 0xef, 0x68, 0x33, 0xbc, 0xcc, 0x95, 0xa7, 0xba, 0x2e, 0xf5, 0xd3, 0xb5, 0x6b, 0xf8, 0x5d,
+	0x4a, 0x17, 0xde, 0xec, 0xda, 0x82, 0x69, 0x97, 0xf8, 0x6d, 0xd7, 0x0a, 0x4b, 0x60, 0x13, 0x03,
+	0x97, 0xc0, 0x0a, 0x8c, 0x92, 0x83, 0xe4, 0x7f, 0x1b, 0x01, 0xe8, 0x7a, 0xb1, 0xf3, 0x6f, 0xb5,
+	0x06, 0xc7, 0x12, 0xf5, 0xa1, 0xb9, 0x3e, 0x2d, 0x04, 0xde, 0x92, 0x09, 0x74, 0x89, 0xdc, 0x82,
+	0x0b, 0x48, 0x63, 0x46, 0x1d, 0x49, 0x18, 0xf5, 0xdc, 0xf6, 0xc0, 0x1e, 0x4c, 0xb2, 0xab, 0x6e,
+	0x2c, 0x0b, 0x67, 0xa7, 0xe8, 0xdd, 0x7e, 0xea, 0xd6, 0xb1, 0xaf, 0x1d, 0x05, 0x3a, 0xb3, 0xcb,
+	0x09, 0x34, 0x13, 0x07, 0x3b, 0x7c, 0x8e, 0xee, 0x2c, 0x16, 0x60, 0xf0, 0x4d, 0x23, 0x76, 0x16,
+	0x03, 0x46, 0xb6, 0xc6, 0xf8, 0x9b, 0x6d, 0x0d, 0xf9, 0x5f, 0x24, 0xb8, 0xfc, 0xf4, 0xd8, 0x22,
+	0x7a, 0xb7, 0xdf, 0x16, 0x46, 0x20, 0x7b, 0x91, 0xfb, 0x4f, 0xec, 0xb2, 0xba, 0x34, 0xd8, 0xa2,
+	0x08, 0x5e, 0x74, 0xad, 0xbb, 0x97, 0x9e, 0xd8, 0xc5, 0xf6, 0x64, 0xef, 0x2d, 0xf7, 0x66, 0xbd,
+	0x37, 0xf9, 0x10, 0xca, 0xbd, 0x13, 0xe0, 0x07, 0xef, 0x79, 0xb6, 0x1e, 0xe5, 0x7d, 0x28, 0xd3,
+	0xb4, 0x50, 0x24, 0x73, 0xf5, 0x93, 0xb0, 0xcf, 0x12, 0x2b, 0x1c, 0xe6, 0x86, 0x2b, 0x1c, 0xca,
+	0x3a, 0x5c, 0x49, 0xe1, 0x9b, 0x99, 0x79, 0x4a, 0x67, 0xcb, 0x3c, 0xff, 0x26, 0x07, 0xd7, 0xbb,
+	0x29, 0xbc, 0x17, 0xf6, 0x5a, 0x7e, 0x3b, 0xfd, 0x2d, 0xf4, 0x05, 0x8c, 0x45, 0x7a, 0x09, 0xd3,
+	0x69, 0x37, 0xda, 0xfa, 0x69, 0x53, 0x65, 0x6d, 0x05, 0x85, 0x33, 0x92, 0xbf, 0x86, 0x31, 0xde,
+	0xb1, 0x98, 0x03, 0xb4, 0xb1, 0xb5, 0xbd, 0xb7, 0xae, 0xa8, 0xcf, 0x76, 0x76, 0x1b, 0xeb, 0xab,
+	0x5b, 0x1b, 0x5b, 0xeb, 0x6b, 0xa5, 0x0b, 0xe8, 0x0e, 0xdc, 0xe4, 0xf0, 0xda, 0xf6, 0xb6, 0x5a,
+	0x5b, 0xdd, 0xdb, 0xda, 0x5f, 0x57, 0x9f, 0x6f, 0xed, 0x6d, 0xaa, 0x3b, 0x4f, 0x77, 0xbe, 0x5a,
+	0x57, 0x9e, 0xaa, 0xf5, 0xda, 0x76, 0x6d, 0x67, 0x75, 0x7d, 0xb7, 0x24, 0xa1, 0x69, 0x80, 0x2e,
+	0x72, 0x29, 0x27, 0x13, 0xb8, 0x71, 0x8a, 0x46, 0x7c, 0x39, 0x7e, 0x0f, 0x80, 0xde, 0xa0, 0x60,
+	0xe5, 0x7f, 0x69, 0xd0, 0xf2, 0xff, 0x44, 0x47, 0x3c, 0xca, 0x7f, 0x9d, 0x83, 0xf7, 0x12, 0xf5,
+	0x90, 0xf4, 0xb5, 0x78, 0x16, 0x5a, 0x50, 0xa2, 0x16, 0xfc, 0xbc, 0xd7, 0x82, 0x83, 0xf0, 0x49,
+	0x58, 0xb1, 0x77, 0x89, 0x73, 0x67, 0xef, 0x76, 0xf5, 0x5b, 0x8f, 0x4b, 0x50, 0xe2, 0xf0, 0xd5,
+	0xed, 0xda, 0xd6, 0x93, 0x5a, 0x7d, 0x7b, 0xbd, 0x24, 0xa1, 0xab, 0x50, 0xe6, 0xd0, 0x9d, 0xa7,
+	0x7b, 0xea, 0x0f, 0xd7, 0xf7, 0x22, 0xa3, 0x39, 0xf9, 0x4f, 0x25, 0x78, 0xbf, 0xcf, 0xbc, 0xce,
+	0x6b, 0x2d, 0xd0, 0x55, 0x98, 0xa0, 0xc7, 0x6c, 0x10, 0x07, 0xf1, 0x7e, 0x40, 0x17, 0xb0, 0xf2,
+	0xb7, 0x97, 0x61, 0x32, 0x40, 0xdb, 0x25, 0x6e, 0xc7, 0xa0, 0x9d, 0xa4, 0x31, 0x96, 0x15, 0xa1,
+	0x6b, 0x29, 0xa1, 0x5b, 0x34, 0x77, 0xab, 0x5c, 0xcf, 0x46, 0xe0, 0xca, 0xab, 0x30, 0x15, 0x6d,
+	0xa6, 0xa0, 0xf7, 0xb3, 0x28, 0x62, 0x4d, 0x98, 0xca, 0x07, 0xfd, 0xd0, 0x18, 0xfb, 0x25, 0x09,
+	0x3d, 0x82, 0x8b, 0x34, 0x1a, 0x45, 0xf3, 0xbd, 0x24, 0xd1, 0xc6, 0x48, 0xe5, 0x5a, 0xe6, 0x78,
+	0xc8, 0x8b, 0xc0, 0x74, 0x3c, 0xb2, 0x45, 0x37, 0x33, 0x88, 0x92, 0xbd, 0x86, 0xca, 0x42, 0x7f,
+	0xc4, 0x50, 0xcc, 0x13, 0x18, 0x63, 0x75, 0xb7, 0x34, 0x03, 0xc7, 0x0a, 0xa7, 0x69, 0x06, 0x8e,
+	0x97, 0xec, 0x96, 0x24, 0x64, 0xc2, 0x4c, 0xcf, 0xb9, 0x8a, 0x6e, 0x67, 0x10, 0xa6, 0x1c, 0xea,
+	0x95, 0x3b, 0x03, 0xe1, 0x86, 0x05, 0xf2, 0x42, 0xac, 0x00, 0x87, 0x52, 0x96, 0x2a, 0xad, 0xf4,
+	0x57, 0xb9, 0xd9, 0x17, 0x8f, 0x4b, 0xd8, 0x83, 0x89, 0xb0, 0x1a, 0x86, 0xe4, 0x5e, 0xaa, 0x64,
+	0x89, 0xaf, 0xf2, 0xee, 0xa9, 0x38, 0x5d, 0xbd, 0x63, 0xe5, 0xb3, 0x34, 0xbd, 0xd3, 0xea, 0x6e,
+	0x69, 0x7a, 0xa7, 0xd7, 0xe1, 0x34, 0x98, 0x8e, 0x5f, 0x75, 0x48, 0xdb, 0x3d, 0xa9, 0xf7, 0x2d,
+	0xd2, 0x76, 0x4f, 0xc6, 0xad, 0x89, 0x2f, 0x20, 0x2f, 0x2e, 0x2b, 0xa0, 0x94, 0x6c, 0x30, 0x71,
+	0x2f, 0xa2, 0x22, 0x9f, 0x86, 0xd2, 0xd5, 0x3b, 0x7e, 0x2d, 0x21, 0x4d, 0xef, 0xd4, 0xbb, 0x10,
+	0x69, 0x7a, 0x67, 0xdc, 0x70, 0x30, 0xa0, 0x94, 0xbc, 0x32, 0x80, 0x6e, 0xf5, 0x52, 0x67, 0xdc,
+	0x5d, 0xa8, 0xdc, 0x1e, 0x04, 0x95, 0x8b, 0xda, 0x85, 0xbc, 0xe8, 0xce, 0xa7, 0x99, 0x28, 0x71,
+	0xc5, 0x20, 0xcd, 0x44, 0xc9, 0xe6, 0xfe, 0x92, 0x14, 0xe8, 0x9f, 0x2c, 0x3a, 0xa6, 0xe9, 0x9f,
+	0x51, 0x2e, 0x4d, 0xd3, 0x3f, 0xb3, 0x86, 0x69, 0x40, 0x29, 0x59, 0xde, 0x4b, 0x13, 0x95, 0x51,
+	0x98, 0x4c, 0x13, 0x95, 0x59, 0x2d, 0x24, 0x30, 0x1d, 0x2f, 0xf1, 0xa5, 0x2d, 0x7d, 0x6a, 0x75,
+	0x30, 0x6d, 0xe9, 0xd3, 0xab, 0x85, 0x4b, 0x12, 0x3a, 0x80, 0x62, 0xa2, 0xe0, 0x86, 0xd2, 0xce,
+	0xcb, 0xd4, 0xfa, 0x60, 0xe5, 0xd6, 0x00, 0x98, 0x7c, 0x3a, 0xaf, 0x61, 0x36, 0xb5, 0xa0, 0x82,
+	0xaa, 0x7d, 0xeb, 0x26, 0xb1, 0x82, 0x5e, 0x65, 0x71, 0x60, 0x7c, 0x2e, 0xf9, 0xa8, 0xb7, 0xd8,
+	0xb6, 0xd0, 0xbf, 0x56, 0x93, 0x3d, 0xc3, 0x8c, 0x72, 0xd3, 0x92, 0x84, 0x5e, 0x42, 0x29, 0x99,
+	0x06, 0xa4, 0xed, 0x8e, 0x8c, 0x5c, 0x27, 0x6d, 0x77, 0x64, 0x65, 0x15, 0x4b, 0x12, 0xb2, 0x01,
+	0xf5, 0xde, 0x40, 0x43, 0x77, 0x86, 0xb8, 0xc8, 0x5f, 0xf9, 0x70, 0x30, 0x64, 0x6e, 0xc7, 0x1d,
+	0x18, 0xe7, 0xad, 0x4f, 0x74, 0x3d, 0xb3, 0x2b, 0x2a, 0x58, 0xdf, 0x38, 0x05, 0xa3, 0xbb, 0x2e,
+	0x89, 0x56, 0x6a, 0xda, 0xba, 0xa4, 0x77, 0xb8, 0xd3, 0xd6, 0x25, 0xa3, 0x2f, 0xbb, 0x24, 0x21,
+	0x0b, 0x66, 0x7a, 0x7e, 0x1f, 0x9a, 0xea, 0x85, 0x33, 0x7e, 0x5e, 0x9b, 0xea, 0x85, 0xb3, 0x7e,
+	0x70, 0xba, 0x24, 0xa1, 0x63, 0xb8, 0x94, 0xf6, 0x1b, 0x44, 0xf4, 0xbd, 0x41, 0x7f, 0xab, 0xc8,
+	0xa4, 0x56, 0x87, 0xfb, 0x69, 0xe3, 0x92, 0x84, 0xfe, 0x44, 0x82, 0x2b, 0x99, 0x09, 0x04, 0x5a,
+	0x19, 0x3e, 0xff, 0xa9, 0xdc, 0x1d, 0x8a, 0x26, 0x54, 0xe4, 0x2f, 0x25, 0x78, 0xe7, 0xd4, 0x08,
+	0x1a, 0x7d, 0x7c, 0xb6, 0x54, 0xa2, 0xf2, 0xc9, 0xd0, 0x74, 0xa1, 0x52, 0xbb, 0x90, 0x17, 0x3f,
+	0x38, 0x4f, 0x73, 0x3e, 0x89, 0x9f, 0xe8, 0xa7, 0x39, 0x9f, 0xe4, 0xef, 0xd5, 0x97, 0xa4, 0xfa,
+	0x6f, 0xa4, 0x5f, 0x7c, 0x3b, 0x2f, 0xfd, 0xea, 0xdb, 0x79, 0xe9, 0x37, 0xdf, 0xce, 0x4b, 0x7f,
+	0xf1, 0xdd, 0xfc, 0x85, 0x5f, 0x7d, 0x37, 0x7f, 0xe1, 0xd7, 0xdf, 0xcd, 0x5f, 0x80, 0x4b, 0x9a,
+	0xdd, 0xea, 0xe1, 0x51, 0x9f, 0x08, 0xe2, 0xf9, 0x86, 0x6b, 0xfb, 0x76, 0x43, 0xfa, 0x6a, 0xf5,
+	0xd0, 0xf0, 0x8f, 0xda, 0xcd, 0x20, 0xff, 0x5f, 0xd4, 0x6c, 0xaf, 0x65, 0x7b, 0x8b, 0xf4, 0xe7,
+	0x69, 0xc4, 0x5d, 0xec, 0xac, 0x84, 0x8f, 0xda, 0x11, 0x36, 0x2c, 0x6f, 0x31, 0xf9, 0x4f, 0x2d,
+	0xee, 0x07, 0x7f, 0x3b, 0xcb, 0x7f, 0x97, 0x1b, 0x69, 0xec, 0x7f, 0xf9, 0x8f, 0xb9, 0x52, 0x43,
+	0x88, 0x0a, 0x24, 0x54, 0xf7, 0x97, 0xff, 0xb5, 0x0b, 0x7a, 0x11, 0x80, 0x5e, 0xec, 0x2f, 0x7f,
+	0x9b, 0xbb, 0x9a, 0x04, 0xbd, 0x78, 0xd8, 0xa8, 0x8b, 0x68, 0xf2, 0xbf, 0x72, 0x48, 0x0c, 0xdf,
+	0xbb, 0x17, 0x8c, 0xdf, 0xbb, 0xb7, 0xbf, 0xdc, 0x1c, 0xa3, 0x3f, 0x9e, 0xbf, 0xfb, 0x7f, 0x01,
+	0x00, 0x00, 0xff, 0xff, 0xa1, 0xbf, 0x5d, 0xa3, 0x56, 0x43, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -7340,6 +7405,22 @@ func (m *TransactionPlannerRequest) MarshalToSizedBuffer(dAtA []byte) (int, erro
 			dAtA[i] = 0xf2
 		}
 	}
+	if len(m.Spends) > 0 {
+		for iNdEx := len(m.Spends) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Spends[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintView(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x1
+			i--
+			dAtA[i] = 0xaa
+		}
+	}
 	if len(m.Outputs) > 0 {
 		for iNdEx := len(m.Outputs) - 1; iNdEx >= 0; iNdEx-- {
 			{
@@ -7481,6 +7562,53 @@ func (m *TransactionPlannerRequest_Output) MarshalToSizedBuffer(dAtA []byte) (in
 	return len(dAtA) - i, nil
 }
 
+func (m *TransactionPlannerRequest_Spend) 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 *TransactionPlannerRequest_Spend) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TransactionPlannerRequest_Spend) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.Address != nil {
+		{
+			size, err := m.Address.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintView(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x12
+	}
+	if m.Value != nil {
+		{
+			size, err := m.Value.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintView(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
 func (m *TransactionPlannerRequest_Swap) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -10572,6 +10700,12 @@ func (m *TransactionPlannerRequest) Size() (n int) {
 			n += 2 + l + sovView(uint64(l))
 		}
 	}
+	if len(m.Spends) > 0 {
+		for _, e := range m.Spends {
+			l = e.Size()
+			n += 2 + l + sovView(uint64(l))
+		}
+	}
 	if len(m.Swaps) > 0 {
 		for _, e := range m.Swaps {
 			l = e.Size()
@@ -10704,6 +10838,23 @@ func (m *TransactionPlannerRequest_Output) Size() (n int) {
 	return n
 }
 
+func (m *TransactionPlannerRequest_Spend) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Value != nil {
+		l = m.Value.Size()
+		n += 1 + l + sovView(uint64(l))
+	}
+	if m.Address != nil {
+		l = m.Address.Size()
+		n += 1 + l + sovView(uint64(l))
+	}
+	return n
+}
+
 func (m *TransactionPlannerRequest_Swap) Size() (n int) {
 	if m == nil {
 		return 0
@@ -13078,6 +13229,40 @@ func (m *TransactionPlannerRequest) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
+		case 21:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Spends", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowView
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthView
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthView
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Spends = append(m.Spends, &TransactionPlannerRequest_Spend{})
+			if err := m.Spends[len(m.Spends)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		case 30:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field Swaps", wireType)
@@ -13788,6 +13973,128 @@ func (m *TransactionPlannerRequest_Output) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *TransactionPlannerRequest_Spend) 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 ErrIntOverflowView
+			}
+			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: Spend: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Spend: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowView
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthView
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthView
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Value == nil {
+				m.Value = &v18.Value{}
+			}
+			if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowView
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthView
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthView
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Address == nil {
+				m.Address = &v1.Address{}
+			}
+			if err := m.Address.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipView(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthView
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func (m *TransactionPlannerRequest_Swap) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0