From b2932dc607913409f9aac9a455e03dae4f0f9a49 Mon Sep 17 00:00:00 2001 From: Justin Tieri <37750742+jtieri@users.noreply.github.com> Date: Sun, 7 Jul 2024 13:49:03 -0500 Subject: [PATCH 1/4] chore: update penumbra protos to v0.77.2 (#1474) * chore: update penumbra protos to v0.77.2 * chore: re-generate Penumbra code from latest protos * test: temp fix fee market test by swapping out RPC addr --- relayer/chains/cosmos/fee_market_test.go | 2 +- .../core/component/auction/v1/auction.pb.go | 418 +- .../community_pool/v1/community_pool.pb.go | 129 +- .../penumbra/core/component/dex/v1/dex.pb.go | 502 +- .../penumbra/core/component/fee/v1/fee.pb.go | 1141 ++- .../core/component/funding/v1/funding.pb.go | 322 +- .../component/governance/v1/governance.pb.go | 1 - .../penumbra/core/component/ibc/v1/ibc.pb.go | 6 +- .../penumbra/core/component/sct/v1/sct.pb.go | 501 +- .../shielded_pool/v1/shielded_pool.pb.go | 1237 ++- .../core/component/stake/v1/stake.pb.go | 6694 +++++++++++------ relayer/chains/penumbra/view/v1/view.pb.go | 1347 +++- 12 files changed, 8981 insertions(+), 3319 deletions(-) diff --git a/relayer/chains/cosmos/fee_market_test.go b/relayer/chains/cosmos/fee_market_test.go index 746d31ed9..7e321a75d 100644 --- a/relayer/chains/cosmos/fee_market_test.go +++ b/relayer/chains/cosmos/fee_market_test.go @@ -15,7 +15,7 @@ var ( Key: "default", ChainName: "osmosis", ChainID: "osmosis-1", - RPCAddr: "https://rpc.osmosis.strange.love:443", + RPCAddr: "https://osmosis-rpc.polkachu.com:443", AccountPrefix: "osmo", KeyringBackend: "test", DynamicGasPrice: true, 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/community_pool/v1/community_pool.pb.go b/relayer/chains/penumbra/core/component/community_pool/v1/community_pool.pb.go index 0225252dd..106eb536b 100644 --- a/relayer/chains/penumbra/core/component/community_pool/v1/community_pool.pb.go +++ b/relayer/chains/penumbra/core/component/community_pool/v1/community_pool.pb.go @@ -78,6 +78,8 @@ func (m *CommunityPoolParameters) GetCommunityPoolSpendProposalsEnabled() bool { type GenesisContent struct { // CommunityPool parameters. CommunityPoolParams *CommunityPoolParameters `protobuf:"bytes,1,opt,name=community_pool_params,json=communityPoolParams,proto3" json:"community_pool_params,omitempty"` + // The initial balance of the Community Pool. + InitialBalance *v1.Value `protobuf:"bytes,2,opt,name=initial_balance,json=initialBalance,proto3" json:"initial_balance,omitempty"` } func (m *GenesisContent) Reset() { *m = GenesisContent{} } @@ -120,6 +122,13 @@ func (m *GenesisContent) GetCommunityPoolParams() *CommunityPoolParameters { return nil } +func (m *GenesisContent) GetInitialBalance() *v1.Value { + if m != nil { + return m.InitialBalance + } + return nil +} + // Requests the list of all asset balances associated with the Community Pool. type CommunityPoolAssetBalancesRequest struct { // (Optional): The specific asset balances to retrieve, if excluded all will be returned. @@ -224,39 +233,41 @@ func init() { } var fileDescriptor_1c6b5a43fb54145e = []byte{ - // 510 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x94, 0x41, 0x8a, 0xd4, 0x40, - 0x14, 0x86, 0xbb, 0x32, 0xa2, 0x63, 0x8d, 0xb8, 0x88, 0x88, 0x43, 0x83, 0x71, 0xcc, 0x42, 0x5a, - 0xd0, 0xc4, 0xb4, 0x82, 0xd0, 0x8a, 0x60, 0x82, 0x0c, 0x82, 0x03, 0x31, 0x03, 0xbd, 0x90, 0x48, - 0xa8, 0x24, 0x4f, 0x27, 0x90, 0x54, 0xc5, 0xaa, 0x4a, 0xa0, 0x6f, 0x30, 0x4b, 0xcf, 0xe0, 0xd2, - 0x2b, 0x78, 0x01, 0x11, 0x17, 0xb3, 0x74, 0x29, 0xdd, 0x3b, 0x4f, 0x21, 0x95, 0x4c, 0x7a, 0x4c, - 0x6b, 0x4b, 0x23, 0x6e, 0xc2, 0xa3, 0xf2, 0xfd, 0xff, 0x7b, 0xef, 0xa7, 0x12, 0xfc, 0xa4, 0x04, - 0x5a, 0x15, 0x31, 0x27, 0x76, 0xc2, 0x38, 0xd8, 0x09, 0x2b, 0x4a, 0x46, 0x81, 0x4a, 0x55, 0x15, - 0x15, 0xcd, 0xe4, 0x2c, 0x2a, 0x19, 0xcb, 0xed, 0xda, 0x59, 0x39, 0xb1, 0x4a, 0xce, 0x24, 0xd3, - 0x6f, 0x77, 0x7a, 0x4b, 0xe9, 0xad, 0xa5, 0xde, 0x5a, 0xa1, 0x6b, 0x67, 0x68, 0xf6, 0x5b, 0x11, - 0x21, 0x40, 0x2a, 0xdf, 0xa6, 0x68, 0xed, 0xcc, 0x02, 0x5f, 0xf3, 0x3a, 0xa1, 0xcf, 0x58, 0xee, - 0x13, 0x4e, 0x0a, 0x90, 0xc0, 0x85, 0x1e, 0xe0, 0x5b, 0x7d, 0xcf, 0x48, 0x94, 0x40, 0xd3, 0xa8, - 0xe4, 0xac, 0x64, 0x82, 0xe4, 0x22, 0x02, 0x4a, 0xe2, 0x1c, 0xd2, 0x5d, 0xb4, 0x87, 0x46, 0xdb, - 0x81, 0x99, 0xfc, 0x6a, 0x74, 0xa8, 0x58, 0xbf, 0x43, 0x9f, 0xb5, 0xa4, 0x79, 0x8c, 0xf0, 0xe5, - 0x7d, 0xa0, 0x20, 0x32, 0xe1, 0x31, 0x2a, 0x81, 0x4a, 0xbd, 0xc6, 0x57, 0x57, 0xda, 0x94, 0x6a, - 0x06, 0xd1, 0xb8, 0xee, 0x8c, 0x5d, 0x6b, 0xe3, 0x85, 0xad, 0x35, 0x9b, 0x04, 0x57, 0x92, 0xdf, - 0x5e, 0x08, 0x93, 0xe0, 0x9b, 0x3d, 0xfe, 0xa9, 0x4a, 0xc5, 0x25, 0x39, 0xa1, 0x09, 0x88, 0x00, - 0xde, 0x55, 0x20, 0xa4, 0xfe, 0x18, 0x5f, 0x6c, 0xd2, 0x8a, 0xb2, 0x54, 0xec, 0x6a, 0x7b, 0x5b, - 0xa3, 0x9d, 0xf1, 0x8d, 0x95, 0x81, 0xda, 0x34, 0x6b, 0xc7, 0x6a, 0x0c, 0x9e, 0xa7, 0xc1, 0x36, - 0x69, 0x0b, 0x61, 0xbe, 0xc6, 0xe6, 0xdf, 0x5a, 0x88, 0x92, 0x51, 0x01, 0xfa, 0x43, 0x7c, 0x21, - 0x6e, 0xcf, 0x4e, 0x57, 0xbe, 0xbe, 0xae, 0xc3, 0x94, 0xe4, 0x15, 0x04, 0x1d, 0x3d, 0xfe, 0x8a, - 0xf0, 0xa5, 0x97, 0x15, 0xf0, 0xd9, 0x21, 0xf0, 0x3a, 0x4b, 0x40, 0xff, 0x84, 0xf0, 0x70, 0x7d, - 0x43, 0xfd, 0xc5, 0xbf, 0x46, 0xf9, 0xa7, 0x68, 0x86, 0x07, 0xff, 0xc9, 0xad, 0x4d, 0xe1, 0x1e, - 0x72, 0x8f, 0xb7, 0x3e, 0xcf, 0x0d, 0x74, 0x32, 0x37, 0xd0, 0xf7, 0xb9, 0x81, 0xde, 0x2f, 0x8c, - 0xc1, 0xc9, 0xc2, 0x18, 0x7c, 0x5b, 0x18, 0x03, 0x7c, 0x37, 0x61, 0xc5, 0xe6, 0xed, 0x5c, 0xbd, - 0x7f, 0x11, 0xd4, 0x45, 0xf7, 0xd1, 0xab, 0x37, 0x6f, 0x33, 0x79, 0x54, 0xc5, 0x8a, 0xb7, 0x13, - 0x26, 0x0a, 0x26, 0x6c, 0x0e, 0x39, 0x99, 0x01, 0xb7, 0xeb, 0xf1, 0xb2, 0x4c, 0x8e, 0x48, 0x46, - 0x85, 0xbd, 0xf1, 0x57, 0xfa, 0xa8, 0x7f, 0x52, 0x3b, 0x1f, 0xb4, 0x73, 0xbe, 0xe7, 0x79, 0x1f, - 0xb5, 0x91, 0xdf, 0x0d, 0xec, 0xa9, 0x81, 0xbd, 0xe5, 0xc0, 0xbd, 0xe9, 0xac, 0xa9, 0xf3, 0xe5, - 0x0c, 0x0d, 0x15, 0x1a, 0x2e, 0xd1, 0xb0, 0x87, 0x86, 0x53, 0x67, 0xae, 0x3d, 0xd8, 0x14, 0x0d, - 0xf7, 0x7d, 0xf7, 0x00, 0x24, 0x49, 0x89, 0x24, 0x3f, 0xb4, 0x3b, 0x9d, 0x6c, 0x32, 0x51, 0x3a, - 0xf5, 0x3c, 0x15, 0x36, 0xe5, 0x99, 0x72, 0x32, 0x99, 0x3a, 0xf1, 0xf9, 0xe6, 0xe7, 0x70, 0xff, - 0x67, 0x00, 0x00, 0x00, 0xff, 0xff, 0x0e, 0xcb, 0x4c, 0x16, 0xad, 0x04, 0x00, 0x00, + // 529 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x94, 0xc1, 0x8a, 0xd3, 0x40, + 0x18, 0xc7, 0x3b, 0x59, 0xd1, 0x75, 0x56, 0x56, 0x88, 0x88, 0xa5, 0x60, 0x5c, 0x73, 0x90, 0x0a, + 0x9a, 0x98, 0x2a, 0x08, 0x55, 0x04, 0x1b, 0x74, 0x11, 0x5c, 0x88, 0x59, 0xe8, 0x41, 0x2a, 0x61, + 0x9a, 0x7c, 0xba, 0x81, 0x64, 0x26, 0xce, 0x4c, 0x02, 0x7d, 0x03, 0x8f, 0x3e, 0x83, 0x47, 0x5f, + 0xc1, 0x17, 0x10, 0xf1, 0xd0, 0xa3, 0x47, 0x69, 0x6f, 0x3e, 0x85, 0x4c, 0xd2, 0x74, 0x4d, 0xb5, + 0x12, 0xc4, 0x4b, 0xf8, 0x98, 0xf9, 0xfd, 0xff, 0xff, 0xef, 0x9b, 0x64, 0x82, 0x1f, 0x65, 0x40, + 0xf3, 0x74, 0xca, 0x89, 0x1d, 0x32, 0x0e, 0x76, 0xc8, 0xd2, 0x8c, 0x51, 0xa0, 0x52, 0x55, 0x69, + 0x4e, 0x63, 0x39, 0x0b, 0x32, 0xc6, 0x12, 0xbb, 0x70, 0x36, 0x56, 0xac, 0x8c, 0x33, 0xc9, 0xf4, + 0x9b, 0xb5, 0xde, 0x52, 0x7a, 0x6b, 0xad, 0xb7, 0x36, 0xe8, 0xc2, 0xe9, 0x99, 0xcd, 0x28, 0x22, + 0x04, 0x48, 0xe5, 0x5b, 0x16, 0x95, 0x9d, 0x99, 0xe2, 0x2b, 0x6e, 0x2d, 0xf4, 0x18, 0x4b, 0x3c, + 0xc2, 0x49, 0x0a, 0x12, 0xb8, 0xd0, 0x7d, 0x7c, 0xa3, 0xe9, 0x19, 0x88, 0x0c, 0x68, 0x14, 0x64, + 0x9c, 0x65, 0x4c, 0x90, 0x44, 0x04, 0x40, 0xc9, 0x34, 0x81, 0xa8, 0x8b, 0x0e, 0x50, 0x7f, 0xd7, + 0x37, 0xc3, 0x5f, 0x8d, 0x8e, 0x15, 0xeb, 0xd5, 0xe8, 0x93, 0x8a, 0x34, 0xe7, 0x08, 0xef, 0x1f, + 0x02, 0x05, 0x11, 0x0b, 0x97, 0x51, 0x09, 0x54, 0xea, 0x05, 0xbe, 0xbc, 0x11, 0x93, 0xa9, 0x1e, + 0x44, 0xe9, 0xba, 0x37, 0x18, 0x59, 0xad, 0x07, 0xb6, 0xb6, 0x4c, 0xe2, 0x5f, 0x0a, 0x7f, 0xdb, + 0x10, 0xfa, 0x53, 0x7c, 0x31, 0xa6, 0xb1, 0x8c, 0x49, 0x12, 0x4c, 0x49, 0x42, 0x68, 0x08, 0x5d, + 0xad, 0x4c, 0xbc, 0xba, 0x91, 0x58, 0x1d, 0x57, 0xe1, 0x58, 0x63, 0x92, 0xe4, 0xe0, 0xef, 0xaf, + 0x54, 0xa3, 0x4a, 0x64, 0x12, 0x7c, 0xbd, 0x91, 0xfb, 0x58, 0xe1, 0xab, 0x4d, 0xe1, 0xc3, 0xdb, + 0x1c, 0x84, 0xd4, 0x1f, 0xe2, 0xf3, 0xa5, 0x4d, 0x10, 0x47, 0xa2, 0xab, 0x1d, 0xec, 0xf4, 0xf7, + 0x06, 0xd7, 0xb6, 0xc5, 0x94, 0x06, 0xcf, 0x22, 0x7f, 0x97, 0x54, 0x85, 0x30, 0x5f, 0x61, 0xf3, + 0x6f, 0x11, 0x22, 0x63, 0x54, 0x80, 0x7e, 0x1f, 0x9f, 0xab, 0x07, 0x41, 0x6d, 0x06, 0xa9, 0xe9, + 0xc1, 0x57, 0x84, 0x2f, 0xbc, 0xc8, 0x81, 0xcf, 0x8e, 0x81, 0x17, 0x71, 0x08, 0xfa, 0x27, 0x84, + 0x7b, 0xdb, 0x03, 0xf5, 0xe7, 0xff, 0xfa, 0x4a, 0xfe, 0x74, 0x34, 0xbd, 0xa3, 0xff, 0xe4, 0x56, + 0x9d, 0xc2, 0x1d, 0x34, 0x7a, 0xb7, 0xf3, 0x79, 0x61, 0xa0, 0xf9, 0xc2, 0x40, 0xdf, 0x17, 0x06, + 0x7a, 0xbf, 0x34, 0x3a, 0xf3, 0xa5, 0xd1, 0xf9, 0xb6, 0x34, 0x3a, 0xf8, 0x76, 0xc8, 0xd2, 0xf6, + 0x71, 0x23, 0xbd, 0xf9, 0x41, 0xa9, 0x0b, 0xe3, 0xa1, 0x97, 0xaf, 0xdf, 0xc4, 0xf2, 0x24, 0x9f, + 0x2a, 0xde, 0x0e, 0x99, 0x48, 0x99, 0xb0, 0x39, 0x24, 0x64, 0x06, 0xdc, 0x2e, 0x06, 0xeb, 0x32, + 0x3c, 0x21, 0x31, 0x15, 0x76, 0xeb, 0xdb, 0xfe, 0xa0, 0xb9, 0x52, 0x38, 0x1f, 0xb4, 0x33, 0x9e, + 0xeb, 0xba, 0x1f, 0xb5, 0xbe, 0x57, 0x37, 0xec, 0xaa, 0x86, 0xdd, 0x75, 0xc3, 0x8d, 0xee, 0xac, + 0xb1, 0xf3, 0xe5, 0x14, 0x9d, 0x28, 0x74, 0xb2, 0x46, 0x27, 0x0d, 0x74, 0x32, 0x76, 0x16, 0xda, + 0xbd, 0xb6, 0xe8, 0xe4, 0xd0, 0x1b, 0x1d, 0x81, 0x24, 0x11, 0x91, 0xe4, 0x87, 0x76, 0xab, 0x96, + 0x0d, 0x87, 0x4a, 0xa7, 0x9e, 0x2b, 0x61, 0x59, 0x9e, 0x2a, 0x87, 0xc3, 0xb1, 0x33, 0x3d, 0x5b, + 0xfe, 0x64, 0xee, 0xfe, 0x0c, 0x00, 0x00, 0xff, 0xff, 0xf6, 0x50, 0x6d, 0xc8, 0xf5, 0x04, 0x00, + 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -419,6 +430,18 @@ func (m *GenesisContent) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.InitialBalance != nil { + { + size, err := m.InitialBalance.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintCommunityPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } if m.CommunityPoolParams != nil { { size, err := m.CommunityPoolParams.MarshalToSizedBuffer(dAtA[:i]) @@ -539,6 +562,10 @@ func (m *GenesisContent) Size() (n int) { l = m.CommunityPoolParams.Size() n += 1 + l + sovCommunityPool(uint64(l)) } + if m.InitialBalance != nil { + l = m.InitialBalance.Size() + n += 1 + l + sovCommunityPool(uint64(l)) + } return n } @@ -711,6 +738,42 @@ func (m *GenesisContent) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field InitialBalance", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCommunityPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthCommunityPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthCommunityPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.InitialBalance == nil { + m.InitialBalance = &v1.Value{} + } + if err := m.InitialBalance.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipCommunityPool(dAtA[iNdEx:]) 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/fee/v1/fee.pb.go b/relayer/chains/penumbra/core/component/fee/v1/fee.pb.go index 9ffc29b5a..523fc51e9 100644 --- a/relayer/chains/penumbra/core/component/fee/v1/fee.pb.go +++ b/relayer/chains/penumbra/core/component/fee/v1/fee.pb.go @@ -58,7 +58,7 @@ func (x FeeTier_Tier) String() string { } func (FeeTier_Tier) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_80e267509eb0355f, []int{2, 0} + return fileDescriptor_80e267509eb0355f, []int{3, 0} } // Specifies fees paid by a transaction. @@ -117,6 +117,81 @@ func (m *Fee) GetAssetId() *v11.AssetId { return nil } +// Gas usage for a transaction. +// +// Gas used is multiplied by `GasPrices` to determine a `Fee`. +type Gas struct { + // The amount of block space used. + BlockSpace uint64 `protobuf:"varint,1,opt,name=block_space,json=blockSpace,proto3" json:"block_space,omitempty"` + // The amount of compact block space used. + CompactBlockSpace uint64 `protobuf:"varint,2,opt,name=compact_block_space,json=compactBlockSpace,proto3" json:"compact_block_space,omitempty"` + // The amount of verification cost used. + Verification uint64 `protobuf:"varint,3,opt,name=verification,proto3" json:"verification,omitempty"` + // The amount of execution cost used. + Execution uint64 `protobuf:"varint,4,opt,name=execution,proto3" json:"execution,omitempty"` +} + +func (m *Gas) Reset() { *m = Gas{} } +func (m *Gas) String() string { return proto.CompactTextString(m) } +func (*Gas) ProtoMessage() {} +func (*Gas) Descriptor() ([]byte, []int) { + return fileDescriptor_80e267509eb0355f, []int{1} +} +func (m *Gas) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Gas) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Gas.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 *Gas) XXX_Merge(src proto.Message) { + xxx_messageInfo_Gas.Merge(m, src) +} +func (m *Gas) XXX_Size() int { + return m.Size() +} +func (m *Gas) XXX_DiscardUnknown() { + xxx_messageInfo_Gas.DiscardUnknown(m) +} + +var xxx_messageInfo_Gas proto.InternalMessageInfo + +func (m *Gas) GetBlockSpace() uint64 { + if m != nil { + return m.BlockSpace + } + return 0 +} + +func (m *Gas) GetCompactBlockSpace() uint64 { + if m != nil { + return m.CompactBlockSpace + } + return 0 +} + +func (m *Gas) GetVerification() uint64 { + if m != nil { + return m.Verification + } + return 0 +} + +func (m *Gas) GetExecution() uint64 { + if m != nil { + return m.Execution + } + return 0 +} + type GasPrices struct { // The asset ID of the fee token these prices are for. // @@ -136,7 +211,7 @@ func (m *GasPrices) Reset() { *m = GasPrices{} } func (m *GasPrices) String() string { return proto.CompactTextString(m) } func (*GasPrices) ProtoMessage() {} func (*GasPrices) Descriptor() ([]byte, []int) { - return fileDescriptor_80e267509eb0355f, []int{1} + return fileDescriptor_80e267509eb0355f, []int{2} } func (m *GasPrices) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -209,7 +284,7 @@ func (m *FeeTier) Reset() { *m = FeeTier{} } func (m *FeeTier) String() string { return proto.CompactTextString(m) } func (*FeeTier) ProtoMessage() {} func (*FeeTier) Descriptor() ([]byte, []int) { - return fileDescriptor_80e267509eb0355f, []int{2} + return fileDescriptor_80e267509eb0355f, []int{3} } func (m *FeeTier) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -268,7 +343,7 @@ func (m *FeeParameters) Reset() { *m = FeeParameters{} } func (m *FeeParameters) String() string { return proto.CompactTextString(m) } func (*FeeParameters) ProtoMessage() {} func (*FeeParameters) Descriptor() ([]byte, []int) { - return fileDescriptor_80e267509eb0355f, []int{3} + return fileDescriptor_80e267509eb0355f, []int{4} } func (m *FeeParameters) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -321,7 +396,7 @@ func (m *GenesisContent) Reset() { *m = GenesisContent{} } func (m *GenesisContent) String() string { return proto.CompactTextString(m) } func (*GenesisContent) ProtoMessage() {} func (*GenesisContent) Descriptor() ([]byte, []int) { - return fileDescriptor_80e267509eb0355f, []int{4} + return fileDescriptor_80e267509eb0355f, []int{5} } func (m *GenesisContent) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -364,7 +439,7 @@ func (m *CurrentGasPricesRequest) Reset() { *m = CurrentGasPricesRequest func (m *CurrentGasPricesRequest) String() string { return proto.CompactTextString(m) } func (*CurrentGasPricesRequest) ProtoMessage() {} func (*CurrentGasPricesRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_80e267509eb0355f, []int{5} + return fileDescriptor_80e267509eb0355f, []int{6} } func (m *CurrentGasPricesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -404,7 +479,7 @@ func (m *CurrentGasPricesResponse) Reset() { *m = CurrentGasPricesRespon func (m *CurrentGasPricesResponse) String() string { return proto.CompactTextString(m) } func (*CurrentGasPricesResponse) ProtoMessage() {} func (*CurrentGasPricesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_80e267509eb0355f, []int{6} + return fileDescriptor_80e267509eb0355f, []int{7} } func (m *CurrentGasPricesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -447,15 +522,155 @@ func (m *CurrentGasPricesResponse) GetAltGasPrices() []*GasPrices { return nil } +// Emitted during fee payment. +type EventPaidFee struct { + // The fee paid. + Fee *Fee `protobuf:"bytes,1,opt,name=fee,proto3" json:"fee,omitempty"` + // The base fee that was required. + BaseFee *Fee `protobuf:"bytes,2,opt,name=base_fee,json=baseFee,proto3" json:"base_fee,omitempty"` + // The tip that was paid to the proposer. + Tip *Fee `protobuf:"bytes,3,opt,name=tip,proto3" json:"tip,omitempty"` + // The gas used to compute the base fee. + GasUsed *Gas `protobuf:"bytes,4,opt,name=gas_used,json=gasUsed,proto3" json:"gas_used,omitempty"` +} + +func (m *EventPaidFee) Reset() { *m = EventPaidFee{} } +func (m *EventPaidFee) String() string { return proto.CompactTextString(m) } +func (*EventPaidFee) ProtoMessage() {} +func (*EventPaidFee) Descriptor() ([]byte, []int) { + return fileDescriptor_80e267509eb0355f, []int{8} +} +func (m *EventPaidFee) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EventPaidFee) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EventPaidFee.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 *EventPaidFee) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventPaidFee.Merge(m, src) +} +func (m *EventPaidFee) XXX_Size() int { + return m.Size() +} +func (m *EventPaidFee) XXX_DiscardUnknown() { + xxx_messageInfo_EventPaidFee.DiscardUnknown(m) +} + +var xxx_messageInfo_EventPaidFee proto.InternalMessageInfo + +func (m *EventPaidFee) GetFee() *Fee { + if m != nil { + return m.Fee + } + return nil +} + +func (m *EventPaidFee) GetBaseFee() *Fee { + if m != nil { + return m.BaseFee + } + return nil +} + +func (m *EventPaidFee) GetTip() *Fee { + if m != nil { + return m.Tip + } + return nil +} + +func (m *EventPaidFee) GetGasUsed() *Gas { + if m != nil { + return m.GasUsed + } + return nil +} + +// Emitted as a summary of fees in the block. +type EventBlockFees struct { + // The total fees, after swapping to the native token. + SwappedFeeTotal *Fee `protobuf:"bytes,1,opt,name=swapped_fee_total,json=swappedFeeTotal,proto3" json:"swapped_fee_total,omitempty"` + // The total base fees, after swapping to the native token. + SwappedBaseFeeTotal *Fee `protobuf:"bytes,2,opt,name=swapped_base_fee_total,json=swappedBaseFeeTotal,proto3" json:"swapped_base_fee_total,omitempty"` + // The total tips, after swapping to the native token. + SwappedTipTotal *Fee `protobuf:"bytes,3,opt,name=swapped_tip_total,json=swappedTipTotal,proto3" json:"swapped_tip_total,omitempty"` +} + +func (m *EventBlockFees) Reset() { *m = EventBlockFees{} } +func (m *EventBlockFees) String() string { return proto.CompactTextString(m) } +func (*EventBlockFees) ProtoMessage() {} +func (*EventBlockFees) Descriptor() ([]byte, []int) { + return fileDescriptor_80e267509eb0355f, []int{9} +} +func (m *EventBlockFees) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EventBlockFees) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EventBlockFees.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 *EventBlockFees) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventBlockFees.Merge(m, src) +} +func (m *EventBlockFees) XXX_Size() int { + return m.Size() +} +func (m *EventBlockFees) XXX_DiscardUnknown() { + xxx_messageInfo_EventBlockFees.DiscardUnknown(m) +} + +var xxx_messageInfo_EventBlockFees proto.InternalMessageInfo + +func (m *EventBlockFees) GetSwappedFeeTotal() *Fee { + if m != nil { + return m.SwappedFeeTotal + } + return nil +} + +func (m *EventBlockFees) GetSwappedBaseFeeTotal() *Fee { + if m != nil { + return m.SwappedBaseFeeTotal + } + return nil +} + +func (m *EventBlockFees) GetSwappedTipTotal() *Fee { + if m != nil { + return m.SwappedTipTotal + } + return nil +} + func init() { proto.RegisterEnum("penumbra.core.component.fee.v1.FeeTier_Tier", FeeTier_Tier_name, FeeTier_Tier_value) proto.RegisterType((*Fee)(nil), "penumbra.core.component.fee.v1.Fee") + proto.RegisterType((*Gas)(nil), "penumbra.core.component.fee.v1.Gas") proto.RegisterType((*GasPrices)(nil), "penumbra.core.component.fee.v1.GasPrices") proto.RegisterType((*FeeTier)(nil), "penumbra.core.component.fee.v1.FeeTier") proto.RegisterType((*FeeParameters)(nil), "penumbra.core.component.fee.v1.FeeParameters") proto.RegisterType((*GenesisContent)(nil), "penumbra.core.component.fee.v1.GenesisContent") proto.RegisterType((*CurrentGasPricesRequest)(nil), "penumbra.core.component.fee.v1.CurrentGasPricesRequest") proto.RegisterType((*CurrentGasPricesResponse)(nil), "penumbra.core.component.fee.v1.CurrentGasPricesResponse") + proto.RegisterType((*EventPaidFee)(nil), "penumbra.core.component.fee.v1.EventPaidFee") + proto.RegisterType((*EventBlockFees)(nil), "penumbra.core.component.fee.v1.EventBlockFees") } func init() { @@ -463,53 +678,65 @@ func init() { } var fileDescriptor_80e267509eb0355f = []byte{ - // 732 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x94, 0x4f, 0x4f, 0xdb, 0x48, - 0x18, 0xc6, 0x63, 0x27, 0x82, 0x64, 0x80, 0x24, 0x58, 0x68, 0x17, 0xd0, 0xca, 0x8b, 0x7c, 0x59, - 0x16, 0x15, 0x5b, 0x49, 0x2b, 0xb5, 0x4d, 0x4f, 0x24, 0xc4, 0x21, 0x15, 0x14, 0xd7, 0x01, 0x2a, - 0xa1, 0xa8, 0xd1, 0xc4, 0x79, 0x03, 0x56, 0x63, 0x3b, 0xf5, 0x8c, 0x53, 0xf8, 0x00, 0xed, 0xb9, - 0xa7, 0x1e, 0x7b, 0xe8, 0xb1, 0x77, 0xee, 0x3d, 0x56, 0x3d, 0x71, 0xec, 0xb1, 0x0a, 0xb7, 0x7e, - 0x8a, 0x6a, 0xc6, 0x89, 0x93, 0x80, 0x0a, 0x45, 0x5c, 0x92, 0xf9, 0xf3, 0x7b, 0x9e, 0x79, 0xdf, - 0xc7, 0xa3, 0x41, 0xab, 0x5d, 0x70, 0x03, 0xa7, 0xe9, 0x63, 0xcd, 0xf2, 0x7c, 0xd0, 0x2c, 0xcf, - 0xe9, 0x7a, 0x2e, 0xb8, 0x54, 0x6b, 0x03, 0x68, 0xbd, 0x1c, 0xfb, 0x53, 0xbb, 0xbe, 0x47, 0x3d, - 0x49, 0x1e, 0x92, 0x2a, 0x23, 0xd5, 0x88, 0x54, 0x19, 0xd2, 0xcb, 0x2d, 0x2b, 0x93, 0x4e, 0x98, - 0x10, 0xa0, 0xcc, 0x81, 0x0f, 0x42, 0x8f, 0x65, 0x79, 0x92, 0x71, 0x03, 0x87, 0x11, 0x6e, 0xe0, - 0x84, 0xfb, 0xca, 0x1b, 0x14, 0xd7, 0x01, 0xa4, 0x07, 0x68, 0x0a, 0x3b, 0x5e, 0xe0, 0xd2, 0x45, - 0x61, 0x45, 0x58, 0x9d, 0xc9, 0xff, 0xa3, 0x4e, 0x9e, 0xcd, 0x04, 0xbd, 0x9c, 0xba, 0xc1, 0x19, - 0x73, 0xc0, 0x4a, 0x05, 0x94, 0xe4, 0x67, 0x35, 0xec, 0xd6, 0xa2, 0xc8, 0x75, 0xff, 0x5e, 0xd2, - 0x85, 0xa5, 0x30, 0x25, 0x1b, 0x54, 0x5b, 0xe6, 0x34, 0x0e, 0x07, 0xca, 0x3b, 0x11, 0xa5, 0x2a, - 0x98, 0x18, 0xbe, 0x6d, 0x01, 0x99, 0x70, 0xca, 0xdc, 0xce, 0x49, 0x5a, 0x43, 0xf3, 0xcd, 0x8e, - 0x67, 0xbd, 0x6a, 0x90, 0x2e, 0xb6, 0xa0, 0xd1, 0x65, 0x8e, 0xbc, 0x8d, 0x84, 0x99, 0xe1, 0x1b, - 0x35, 0xb6, 0xce, 0x0f, 0x92, 0x1e, 0xa3, 0x25, 0x16, 0x23, 0xb6, 0x68, 0xe3, 0xaa, 0x46, 0xe4, - 0x9a, 0xbf, 0x06, 0x40, 0xf1, 0x92, 0x74, 0x1d, 0x49, 0x3d, 0xf0, 0xed, 0xb6, 0x6d, 0x61, 0x6a, - 0x7b, 0xee, 0x40, 0x13, 0xe7, 0x9a, 0xf9, 0xf1, 0x9d, 0x10, 0xff, 0x0f, 0x65, 0xe0, 0x04, 0xac, - 0x60, 0x8c, 0x4d, 0x70, 0x36, 0x1d, 0x2d, 0x73, 0x50, 0xf9, 0x28, 0xa0, 0x69, 0x1d, 0x60, 0xcf, - 0x06, 0x5f, 0xaa, 0xa0, 0x64, 0x1b, 0xa0, 0x41, 0x6d, 0xf0, 0x79, 0x07, 0xe9, 0xfc, 0x3d, 0xf5, - 0xfa, 0x4b, 0xa0, 0x0e, 0xa4, 0x2a, 0xfb, 0x31, 0xa7, 0xdb, 0xe1, 0x4c, 0x79, 0x8a, 0x12, 0xdc, - 0x70, 0x01, 0x65, 0xf7, 0xaa, 0x65, 0xb3, 0xb1, 0xff, 0xac, 0x66, 0x94, 0x4b, 0x55, 0xbd, 0x5a, - 0xde, 0xcc, 0xc6, 0xa4, 0x59, 0x94, 0xe4, 0xab, 0xdb, 0xbb, 0x2f, 0xb2, 0x82, 0x94, 0x41, 0x33, - 0x7c, 0xb6, 0x53, 0xde, 0xac, 0xee, 0xef, 0x64, 0x45, 0x69, 0x0e, 0xa5, 0xf8, 0xc2, 0x56, 0xb5, - 0xb2, 0x95, 0x8d, 0x2b, 0x5f, 0x04, 0x34, 0xa7, 0x03, 0x18, 0xd8, 0xc7, 0x0e, 0x50, 0xf0, 0x89, - 0x54, 0x43, 0xd9, 0xb6, 0x7d, 0x02, 0xad, 0xc6, 0x11, 0x26, 0x61, 0x6f, 0x64, 0x70, 0x6f, 0xfe, - 0xbf, 0xa9, 0xdc, 0xe8, 0x93, 0x9b, 0x69, 0x6e, 0x31, 0xba, 0x02, 0x87, 0x68, 0x21, 0x34, 0xc5, - 0x1d, 0x3a, 0x6e, 0x2c, 0xae, 0xc4, 0x6f, 0x67, 0x3c, 0xcf, 0x6d, 0x36, 0x3a, 0x34, 0x5a, 0x52, - 0x5e, 0xa2, 0x74, 0x05, 0x5c, 0x20, 0x36, 0x29, 0x79, 0x2e, 0x05, 0x97, 0x4a, 0xdb, 0x08, 0xb1, - 0xa4, 0xbb, 0xac, 0xa9, 0x61, 0xf1, 0xeb, 0x7f, 0x90, 0xf5, 0x28, 0x05, 0x33, 0xd5, 0x1e, 0x4c, - 0x89, 0xb2, 0x84, 0xfe, 0x2e, 0x05, 0xbe, 0x0f, 0xee, 0xe8, 0x4c, 0x13, 0x5e, 0x07, 0x40, 0xa8, - 0x72, 0x26, 0xa0, 0xc5, 0xab, 0x7b, 0xa4, 0xeb, 0xb9, 0x04, 0xa4, 0x2d, 0x84, 0xee, 0x12, 0x61, - 0xea, 0x28, 0x4a, 0x6f, 0x17, 0xa5, 0xef, 0x9a, 0xdb, 0x2c, 0x1e, 0x8b, 0x2c, 0xff, 0x41, 0x40, - 0xb3, 0xcf, 0x03, 0xf0, 0x4f, 0x6b, 0xe0, 0xf7, 0xd8, 0x85, 0x7e, 0x2b, 0xa0, 0xec, 0xe5, 0x46, - 0xa4, 0x87, 0x37, 0xd9, 0xff, 0x26, 0x96, 0xe5, 0x47, 0xb7, 0x17, 0x86, 0x99, 0x15, 0xcf, 0xc4, - 0xaf, 0x7d, 0x59, 0x38, 0xef, 0xcb, 0xc2, 0x8f, 0xbe, 0x2c, 0xbc, 0xbf, 0x90, 0x63, 0xe7, 0x17, - 0x72, 0xec, 0xfb, 0x85, 0x1c, 0x43, 0x8a, 0xe5, 0x39, 0x37, 0xf8, 0x16, 0x93, 0xec, 0x23, 0xb2, - 0xa7, 0xcf, 0x10, 0x0e, 0x8d, 0x23, 0x9b, 0x1e, 0x07, 0x4d, 0x06, 0x69, 0x96, 0x47, 0x1c, 0x8f, - 0x68, 0x3e, 0x74, 0xf0, 0x29, 0xf8, 0x5a, 0x2f, 0x1f, 0x0d, 0xad, 0x63, 0x6c, 0xbb, 0x44, 0xbb, - 0xfe, 0xd9, 0x7e, 0xd2, 0x06, 0xe8, 0xe5, 0x3e, 0x89, 0x09, 0xa3, 0x54, 0xd2, 0x3f, 0x8b, 0xb2, - 0x31, 0xac, 0xa2, 0xc4, 0xaa, 0x28, 0x45, 0x55, 0xe8, 0x00, 0xea, 0x41, 0xee, 0xdb, 0x08, 0xa8, - 0x33, 0xa0, 0x1e, 0x01, 0x75, 0x1d, 0xa0, 0x7e, 0x90, 0xeb, 0x8b, 0x6b, 0xd7, 0x03, 0xf5, 0x8a, - 0x51, 0xdc, 0x01, 0x8a, 0x5b, 0x98, 0xe2, 0x9f, 0xa2, 0x32, 0x84, 0x0b, 0x05, 0x46, 0xb3, 0xdf, - 0x01, 0x5e, 0x28, 0xe8, 0x00, 0x85, 0xc2, 0x41, 0xae, 0x39, 0xc5, 0x1f, 0xfc, 0xfb, 0xbf, 0x02, - 0x00, 0x00, 0xff, 0xff, 0x3a, 0xdd, 0x61, 0xb6, 0x80, 0x06, 0x00, 0x00, + // 928 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0xcf, 0x8f, 0xdb, 0x44, + 0x14, 0x5e, 0x3b, 0xab, 0x26, 0x79, 0x9b, 0xe6, 0xc7, 0xb4, 0x2a, 0xdb, 0x55, 0xe5, 0x56, 0xe6, + 0x40, 0xa9, 0xa8, 0xa3, 0x2c, 0x20, 0x20, 0x48, 0x48, 0x4d, 0x1a, 0x67, 0x83, 0xba, 0xd4, 0x78, + 0x7f, 0x80, 0xaa, 0x08, 0x6b, 0xe2, 0xbc, 0x6c, 0x2d, 0x12, 0xdb, 0x78, 0xc6, 0x69, 0xfb, 0x07, + 0xc0, 0x89, 0x03, 0x27, 0xc4, 0x89, 0x03, 0x47, 0xee, 0xbd, 0x73, 0x44, 0x9c, 0x7a, 0xe4, 0x88, + 0x76, 0x6f, 0xfc, 0x0d, 0x1c, 0xd0, 0x8c, 0x1d, 0x27, 0x69, 0x61, 0x37, 0x51, 0x2f, 0xd9, 0xf1, + 0x9b, 0xef, 0xfb, 0xde, 0xfb, 0xbe, 0x9d, 0x71, 0x02, 0xb7, 0x43, 0xf4, 0xe3, 0xc9, 0x20, 0xa2, + 0x75, 0x37, 0x88, 0xb0, 0xee, 0x06, 0x93, 0x30, 0xf0, 0xd1, 0xe7, 0xf5, 0x11, 0x62, 0x7d, 0xda, + 0x10, 0x7f, 0x8c, 0x30, 0x0a, 0x78, 0x40, 0xb4, 0x19, 0xd2, 0x10, 0x48, 0x23, 0x43, 0x1a, 0x02, + 0x32, 0x6d, 0xec, 0xe8, 0xcb, 0x4a, 0x94, 0x31, 0xe4, 0x42, 0x41, 0x2e, 0x12, 0x8d, 0x1d, 0x6d, + 0x19, 0xe3, 0xc7, 0x13, 0x81, 0xf0, 0xe3, 0x49, 0xb2, 0xaf, 0x3f, 0x81, 0x9c, 0x89, 0x48, 0xde, + 0x83, 0x4b, 0x74, 0x12, 0xc4, 0x3e, 0xdf, 0x56, 0x6e, 0x29, 0xb7, 0xb7, 0x76, 0x6f, 0x18, 0xcb, + 0xbd, 0x05, 0x61, 0xda, 0x30, 0xee, 0x49, 0x8c, 0x9d, 0x62, 0x49, 0x13, 0x0a, 0xb2, 0x97, 0xe3, + 0x0d, 0xb7, 0x55, 0xc9, 0xbb, 0xf9, 0x12, 0x2f, 0x19, 0x45, 0x30, 0xc5, 0xa2, 0x37, 0xb4, 0xf3, + 0x34, 0x59, 0xe8, 0x3f, 0x29, 0x90, 0xeb, 0x52, 0x46, 0x6e, 0xc2, 0xd6, 0x60, 0x1c, 0xb8, 0x5f, + 0x3b, 0x2c, 0xa4, 0x2e, 0xca, 0xf6, 0x9b, 0x36, 0xc8, 0xd2, 0x81, 0xa8, 0x10, 0x03, 0xae, 0x08, + 0xe7, 0xd4, 0xe5, 0xce, 0x22, 0x50, 0x95, 0xc0, 0x5a, 0xba, 0xd5, 0x9a, 0xe3, 0x75, 0x28, 0x4d, + 0x31, 0xf2, 0x46, 0x9e, 0x4b, 0xb9, 0x17, 0xf8, 0xdb, 0x39, 0x09, 0x5c, 0xaa, 0x91, 0x1b, 0x50, + 0xc4, 0xa7, 0xe8, 0xc6, 0x12, 0xb0, 0x29, 0x01, 0xf3, 0x82, 0xfe, 0x9d, 0x0a, 0xc5, 0x2e, 0x65, + 0x56, 0xe4, 0xb9, 0xc8, 0x96, 0x4c, 0x56, 0xd6, 0x33, 0x49, 0xee, 0x40, 0x6d, 0x61, 0x66, 0x27, + 0x14, 0x8a, 0xa9, 0xc5, 0xca, 0xdc, 0xa2, 0x6c, 0x44, 0x3e, 0x82, 0xeb, 0xff, 0xe1, 0x33, 0xe5, + 0x24, 0x6e, 0xaf, 0xbd, 0xe2, 0x36, 0xa1, 0xde, 0x05, 0xb2, 0x68, 0x2f, 0xe5, 0x24, 0xc6, 0x6b, + 0x8b, 0x3b, 0x09, 0xfc, 0x2d, 0xa8, 0x64, 0x66, 0x53, 0x6c, 0x92, 0x41, 0x39, 0x2b, 0x4b, 0xa0, + 0xfe, 0xb3, 0x02, 0x79, 0x13, 0xf1, 0xd0, 0xc3, 0x88, 0x74, 0xa1, 0x30, 0x42, 0x74, 0xb8, 0x87, + 0x91, 0x74, 0x50, 0xde, 0x7d, 0xc7, 0x38, 0xff, 0x7c, 0x1a, 0x29, 0xd5, 0x10, 0x1f, 0x76, 0x7e, + 0x94, 0x3c, 0xe9, 0x9f, 0xc2, 0xa6, 0x14, 0xbc, 0x0a, 0xd5, 0xc3, 0x5e, 0xc7, 0x76, 0x8e, 0x3e, + 0x3b, 0xb0, 0x3a, 0xed, 0x9e, 0xd9, 0xeb, 0xdc, 0xaf, 0x6e, 0x90, 0x12, 0x14, 0x64, 0xf5, 0xc1, + 0xc3, 0x2f, 0xaa, 0x0a, 0xa9, 0xc0, 0x96, 0x7c, 0xda, 0xef, 0xdc, 0xef, 0x1d, 0xed, 0x57, 0x55, + 0x72, 0x19, 0x8a, 0xb2, 0xb0, 0xd7, 0xeb, 0xee, 0x55, 0x73, 0xfa, 0x6f, 0x0a, 0x5c, 0x36, 0x11, + 0x2d, 0x1a, 0xd1, 0x09, 0x72, 0x8c, 0x18, 0x39, 0x80, 0xea, 0xc8, 0x7b, 0x8a, 0x43, 0xe7, 0x84, + 0xb2, 0xc4, 0x1b, 0x4b, 0x8f, 0xf4, 0xdb, 0x17, 0x8d, 0x9b, 0xfd, 0xcb, 0xed, 0xb2, 0x94, 0x98, + 0x1f, 0x81, 0x47, 0x70, 0x35, 0x11, 0xa5, 0x63, 0xbe, 0x28, 0xac, 0xde, 0xca, 0xad, 0x27, 0x5c, + 0x93, 0x32, 0xf7, 0xc6, 0x3c, 0x2b, 0xe9, 0x5f, 0x41, 0xb9, 0x8b, 0x3e, 0x32, 0x8f, 0xb5, 0x03, + 0x9f, 0xa3, 0xcf, 0xc9, 0x03, 0x00, 0x91, 0x74, 0x28, 0x4c, 0xcd, 0x86, 0xbf, 0xbb, 0x42, 0xd6, + 0xf3, 0x14, 0xec, 0xe2, 0x28, 0x7d, 0x64, 0xfa, 0x75, 0x78, 0xa3, 0x1d, 0x47, 0x11, 0xfa, 0xf3, + 0x9e, 0x36, 0x7e, 0x13, 0x23, 0xe3, 0xfa, 0x73, 0x05, 0xb6, 0x5f, 0xdd, 0x63, 0x61, 0xe0, 0x33, + 0x24, 0x7b, 0x00, 0xaf, 0x13, 0x61, 0xf1, 0x24, 0x4b, 0xef, 0x21, 0x94, 0x5f, 0x37, 0xb7, 0x12, + 0x5d, 0x8c, 0xec, 0x1f, 0x05, 0x4a, 0x9d, 0x29, 0xfa, 0xdc, 0xa2, 0xde, 0x50, 0xbc, 0xbd, 0xde, + 0x87, 0xdc, 0x08, 0x31, 0x1d, 0xf2, 0xcd, 0x15, 0xa2, 0xb2, 0x05, 0x9e, 0x7c, 0x02, 0x85, 0x01, + 0x65, 0xe8, 0x08, 0xae, 0xba, 0x3a, 0x37, 0x2f, 0x48, 0x69, 0x5b, 0xee, 0x85, 0xf2, 0x9e, 0xad, + 0xda, 0x96, 0x7b, 0xa1, 0x68, 0x2b, 0xb2, 0x88, 0x19, 0x0e, 0xe5, 0xbd, 0x5b, 0x81, 0xdb, 0xa5, + 0xcc, 0xce, 0x9f, 0x50, 0x76, 0xc4, 0x70, 0xa8, 0x7f, 0xaf, 0x42, 0x59, 0xda, 0x97, 0xaf, 0x01, + 0x13, 0x65, 0xc4, 0x35, 0xf6, 0x84, 0x86, 0x21, 0x0e, 0x1d, 0x79, 0x49, 0x03, 0x4e, 0xc7, 0xeb, + 0xc4, 0x51, 0x49, 0xd9, 0xe2, 0xc6, 0x0a, 0x2e, 0xf9, 0x12, 0xae, 0xcd, 0x04, 0x67, 0x11, 0xa5, + 0xaa, 0x6b, 0x04, 0x75, 0x25, 0x95, 0x68, 0x25, 0x79, 0x25, 0xca, 0x0b, 0xa3, 0x72, 0x2f, 0x4c, + 0x45, 0x73, 0xeb, 0x8f, 0x7a, 0xe8, 0x85, 0x52, 0x70, 0xf7, 0x47, 0x05, 0x4a, 0x9f, 0xc7, 0x18, + 0x3d, 0x3b, 0xc0, 0x68, 0x2a, 0x5e, 0x6f, 0xdf, 0x2a, 0x50, 0x7d, 0xf9, 0x58, 0x93, 0x0f, 0x2e, + 0xd2, 0xfe, 0x9f, 0x4b, 0xb2, 0xf3, 0xe1, 0xfa, 0xc4, 0xe4, 0x06, 0xb5, 0x9e, 0xab, 0xbf, 0x9f, + 0x6a, 0xca, 0x8b, 0x53, 0x4d, 0xf9, 0xeb, 0x54, 0x53, 0x7e, 0x38, 0xd3, 0x36, 0x5e, 0x9c, 0x69, + 0x1b, 0x7f, 0x9e, 0x69, 0x1b, 0xa0, 0xbb, 0xc1, 0xe4, 0x02, 0xdd, 0x56, 0x41, 0x5c, 0x69, 0xf1, + 0x1d, 0x6d, 0x29, 0x8f, 0xac, 0x13, 0x8f, 0x3f, 0x8e, 0x07, 0x02, 0x54, 0x77, 0x03, 0x36, 0x09, + 0x58, 0x3d, 0xc2, 0x31, 0x7d, 0x86, 0x51, 0x7d, 0xba, 0x9b, 0x2d, 0xdd, 0xc7, 0xd4, 0xf3, 0x59, + 0xfd, 0xfc, 0xdf, 0x17, 0x1f, 0x8f, 0x10, 0xa7, 0x8d, 0x5f, 0xd4, 0x4d, 0xab, 0xdd, 0x36, 0x7f, + 0x55, 0x35, 0x6b, 0x36, 0x45, 0x5b, 0x4c, 0xd1, 0xce, 0xa6, 0x30, 0x11, 0x8d, 0xe3, 0xc6, 0x1f, + 0x73, 0x40, 0x5f, 0x00, 0xfa, 0x19, 0xa0, 0x6f, 0x22, 0xf6, 0x8f, 0x1b, 0xa7, 0xea, 0x9d, 0xf3, + 0x01, 0xfd, 0xae, 0xd5, 0xda, 0x47, 0x4e, 0x87, 0x94, 0xd3, 0xbf, 0x55, 0x7d, 0x06, 0x6e, 0x36, + 0x05, 0x5a, 0x7c, 0xa6, 0xf0, 0x66, 0xd3, 0x44, 0x6c, 0x36, 0x8f, 0x1b, 0x83, 0x4b, 0xf2, 0x97, + 0xc9, 0xbb, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0x81, 0x53, 0x4d, 0xbd, 0x29, 0x09, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -641,6 +868,49 @@ func (m *Fee) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *Gas) 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 *Gas) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Gas) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Execution != 0 { + i = encodeVarintFee(dAtA, i, uint64(m.Execution)) + i-- + dAtA[i] = 0x20 + } + if m.Verification != 0 { + i = encodeVarintFee(dAtA, i, uint64(m.Verification)) + i-- + dAtA[i] = 0x18 + } + if m.CompactBlockSpace != 0 { + i = encodeVarintFee(dAtA, i, uint64(m.CompactBlockSpace)) + i-- + dAtA[i] = 0x10 + } + if m.BlockSpace != 0 { + i = encodeVarintFee(dAtA, i, uint64(m.BlockSpace)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + func (m *GasPrices) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -880,62 +1150,213 @@ func (m *CurrentGasPricesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error return len(dAtA) - i, nil } -func encodeVarintFee(dAtA []byte, offset int, v uint64) int { - offset -= sovFee(v) - base := offset - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ +func (m *EventPaidFee) 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 *Fee) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Amount != nil { - l = m.Amount.Size() - n += 1 + l + sovFee(uint64(l)) - } - if m.AssetId != nil { - l = m.AssetId.Size() - n += 1 + l + sovFee(uint64(l)) - } - return n + +func (m *EventPaidFee) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *GasPrices) Size() (n int) { - if m == nil { - return 0 - } +func (m *EventPaidFee) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - if m.BlockSpacePrice != 0 { - n += 1 + sovFee(uint64(m.BlockSpacePrice)) - } - if m.CompactBlockSpacePrice != 0 { - n += 1 + sovFee(uint64(m.CompactBlockSpacePrice)) + if m.GasUsed != nil { + { + size, err := m.GasUsed.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintFee(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 } - if m.VerificationPrice != 0 { - n += 1 + sovFee(uint64(m.VerificationPrice)) + if m.Tip != nil { + { + size, err := m.Tip.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintFee(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a } - if m.ExecutionPrice != 0 { - n += 1 + sovFee(uint64(m.ExecutionPrice)) + if m.BaseFee != nil { + { + size, err := m.BaseFee.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintFee(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 } - if m.AssetId != nil { - l = m.AssetId.Size() - n += 1 + l + sovFee(uint64(l)) + if m.Fee != nil { + { + size, err := m.Fee.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintFee(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *FeeTier) Size() (n int) { - if m == nil { - return 0 +func (m *EventBlockFees) 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 *EventBlockFees) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EventBlockFees) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.SwappedTipTotal != nil { + { + size, err := m.SwappedTipTotal.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintFee(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.SwappedBaseFeeTotal != nil { + { + size, err := m.SwappedBaseFeeTotal.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintFee(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.SwappedFeeTotal != nil { + { + size, err := m.SwappedFeeTotal.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintFee(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintFee(dAtA []byte, offset int, v uint64) int { + offset -= sovFee(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *Fee) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Amount != nil { + l = m.Amount.Size() + n += 1 + l + sovFee(uint64(l)) + } + if m.AssetId != nil { + l = m.AssetId.Size() + n += 1 + l + sovFee(uint64(l)) + } + return n +} + +func (m *Gas) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BlockSpace != 0 { + n += 1 + sovFee(uint64(m.BlockSpace)) + } + if m.CompactBlockSpace != 0 { + n += 1 + sovFee(uint64(m.CompactBlockSpace)) + } + if m.Verification != 0 { + n += 1 + sovFee(uint64(m.Verification)) + } + if m.Execution != 0 { + n += 1 + sovFee(uint64(m.Execution)) + } + return n +} + +func (m *GasPrices) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BlockSpacePrice != 0 { + n += 1 + sovFee(uint64(m.BlockSpacePrice)) + } + if m.CompactBlockSpacePrice != 0 { + n += 1 + sovFee(uint64(m.CompactBlockSpacePrice)) + } + if m.VerificationPrice != 0 { + n += 1 + sovFee(uint64(m.VerificationPrice)) + } + if m.ExecutionPrice != 0 { + n += 1 + sovFee(uint64(m.ExecutionPrice)) + } + if m.AssetId != nil { + l = m.AssetId.Size() + n += 1 + l + sovFee(uint64(l)) + } + return n +} + +func (m *FeeTier) Size() (n int) { + if m == nil { + return 0 } var l int _ = l @@ -1005,6 +1426,52 @@ func (m *CurrentGasPricesResponse) Size() (n int) { return n } +func (m *EventPaidFee) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Fee != nil { + l = m.Fee.Size() + n += 1 + l + sovFee(uint64(l)) + } + if m.BaseFee != nil { + l = m.BaseFee.Size() + n += 1 + l + sovFee(uint64(l)) + } + if m.Tip != nil { + l = m.Tip.Size() + n += 1 + l + sovFee(uint64(l)) + } + if m.GasUsed != nil { + l = m.GasUsed.Size() + n += 1 + l + sovFee(uint64(l)) + } + return n +} + +func (m *EventBlockFees) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.SwappedFeeTotal != nil { + l = m.SwappedFeeTotal.Size() + n += 1 + l + sovFee(uint64(l)) + } + if m.SwappedBaseFeeTotal != nil { + l = m.SwappedBaseFeeTotal.Size() + n += 1 + l + sovFee(uint64(l)) + } + if m.SwappedTipTotal != nil { + l = m.SwappedTipTotal.Size() + n += 1 + l + sovFee(uint64(l)) + } + return n +} + func sovFee(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } @@ -1133,6 +1600,132 @@ func (m *Fee) Unmarshal(dAtA []byte) error { } return nil } +func (m *Gas) 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 ErrIntOverflowFee + } + 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: Gas: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Gas: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockSpace", wireType) + } + m.BlockSpace = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFee + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.BlockSpace |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CompactBlockSpace", wireType) + } + m.CompactBlockSpace = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFee + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CompactBlockSpace |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Verification", wireType) + } + m.Verification = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFee + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Verification |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Execution", wireType) + } + m.Execution = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFee + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Execution |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipFee(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthFee + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *GasPrices) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -1740,6 +2333,358 @@ func (m *CurrentGasPricesResponse) Unmarshal(dAtA []byte) error { } return nil } +func (m *EventPaidFee) 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 ErrIntOverflowFee + } + 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: EventPaidFee: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventPaidFee: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Fee", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFee + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFee + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthFee + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Fee == nil { + m.Fee = &Fee{} + } + if err := m.Fee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BaseFee", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFee + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFee + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthFee + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.BaseFee == nil { + m.BaseFee = &Fee{} + } + if err := m.BaseFee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Tip", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFee + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFee + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthFee + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Tip == nil { + m.Tip = &Fee{} + } + if err := m.Tip.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GasUsed", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFee + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFee + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthFee + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.GasUsed == nil { + m.GasUsed = &Gas{} + } + if err := m.GasUsed.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFee(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthFee + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EventBlockFees) 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 ErrIntOverflowFee + } + 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: EventBlockFees: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventBlockFees: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SwappedFeeTotal", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFee + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFee + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthFee + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SwappedFeeTotal == nil { + m.SwappedFeeTotal = &Fee{} + } + if err := m.SwappedFeeTotal.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SwappedBaseFeeTotal", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFee + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFee + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthFee + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SwappedBaseFeeTotal == nil { + m.SwappedBaseFeeTotal = &Fee{} + } + if err := m.SwappedBaseFeeTotal.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SwappedTipTotal", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowFee + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthFee + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthFee + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SwappedTipTotal == nil { + m.SwappedTipTotal = &Fee{} + } + if err := m.SwappedTipTotal.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipFee(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthFee + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipFee(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 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/ibc/v1/ibc.pb.go b/relayer/chains/penumbra/core/component/ibc/v1/ibc.pb.go index 1b01d2a31..69d1683f1 100644 --- a/relayer/chains/penumbra/core/component/ibc/v1/ibc.pb.go +++ b/relayer/chains/penumbra/core/component/ibc/v1/ibc.pb.go @@ -167,9 +167,11 @@ type Ics20Withdrawal struct { // The height on the counterparty chain at which this transfer expires, and // funds are sent back to the return address. TimeoutHeight *types1.Height `protobuf:"bytes,5,opt,name=timeout_height,json=timeoutHeight,proto3" json:"timeout_height,omitempty"` - // the timestamp at which this transfer expires. + // The timestamp, in epoch time, after which this transfer will be considered invalid. + // Clients must quantize this value to the nearest minute, to preserve privacy. + // IBC withdrawals that do not quantize timestamps will be rejected. TimeoutTime uint64 `protobuf:"varint,6,opt,name=timeout_time,json=timeoutTime,proto3" json:"timeout_time,omitempty"` - // the source channel used for the withdrawal + // The source channel used for the withdrawal SourceChannel string `protobuf:"bytes,7,opt,name=source_channel,json=sourceChannel,proto3" json:"source_channel,omitempty"` } 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..b205975b6 100644 --- a/relayer/chains/penumbra/core/component/stake/v1/stake.pb.go +++ b/relayer/chains/penumbra/core/component/stake/v1/stake.pb.go @@ -2106,7 +2106,7 @@ type StakeParameters struct { // The maximum number of validators in the consensus set. ActiveValidatorLimit uint64 `protobuf:"varint,2,opt,name=active_validator_limit,json=activeValidatorLimit,proto3" json:"active_validator_limit,omitempty"` // The base reward rate, expressed in basis points of basis points - BaseRewardRate uint64 `protobuf:"varint,3,opt,name=base_reward_rate,json=baseRewardRate,proto3" json:"base_reward_rate,omitempty"` + BaseRewardRate uint64 `protobuf:"varint,3,opt,name=base_reward_rate,json=baseRewardRate,proto3" json:"base_reward_rate,omitempty"` // Deprecated: Do not use. // The penalty for slashing due to misbehavior. SlashingPenaltyMisbehavior uint64 `protobuf:"varint,4,opt,name=slashing_penalty_misbehavior,json=slashingPenaltyMisbehavior,proto3" json:"slashing_penalty_misbehavior,omitempty"` // The penalty for slashing due to downtime. @@ -2169,6 +2169,7 @@ func (m *StakeParameters) GetActiveValidatorLimit() uint64 { return 0 } +// Deprecated: Do not use. func (m *StakeParameters) GetBaseRewardRate() uint64 { if m != nil { return m.BaseRewardRate @@ -2354,780 +2355,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{ + // 2585 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, 0xd6, 0x43, 0x80, 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, 0xe8, 0xc6, 0x31, 0xb3, 0xb5, 0xa9, 0x68, 0x4c, 0xd2, 0x37, 0x41, 0x7b, + 0x1b, 0xae, 0xd0, 0xb6, 0x49, 0x0f, 0xc4, 0x50, 0xc9, 0x77, 0x1f, 0xc3, 0xb1, 0x69, 0x13, 0x1f, + 0x98, 0x3d, 0xdb, 0xf5, 0xa4, 0x03, 0x2f, 0x05, 0x38, 0xd2, 0xd5, 0xee, 0x46, 0x18, 0x68, 0x03, + 0x2e, 0x0f, 0x70, 0xb0, 0xdc, 0x43, 0x22, 0xac, 0xe7, 0x57, 0x64, 0x97, 0xfa, 0xc8, 0x2b, 0x72, + 0x1b, 0xbd, 0x06, 0x79, 0x6a, 0xef, 0x13, 0x6c, 0xf9, 0x59, 0x8f, 0x1a, 0xb1, 0xac, 0x36, 0x23, + 0x48, 0x2f, 0xf8, 0xfb, 0x22, 0xf9, 0xd1, 0xaf, 0x87, 0x19, 0x6e, 0x1d, 0x2e, 0x38, 0x36, 0xa5, + 0x11, 0xa1, 0x63, 0x7e, 0x60, 0x3b, 0x5d, 0x47, 0x94, 0x1f, 0x29, 0xfd, 0x9c, 0xbf, 0xe9, 0x53, + 0xdd, 0xf5, 0xb7, 0xd0, 0x1d, 0x38, 0xe7, 0xd8, 0x24, 0x66, 0x4b, 0x71, 0x75, 0xa2, 0x0c, 0x19, + 0x56, 0x24, 0x2d, 0x3a, 0x36, 0x89, 0x07, 0xa1, 0x47, 0x18, 0xbd, 0x00, 0xd1, 0x7d, 0x19, 0x16, + 0x6e, 0x9b, 0x47, 0xb2, 0x40, 0xc9, 0x86, 0xe0, 0x0a, 0x87, 0x6a, 0x3f, 0x57, 0x20, 0xbb, 0x85, + 0x09, 0xa6, 0x36, 0x2d, 0xbb, 0x84, 0xf1, 0x0a, 0x76, 0x07, 0xd2, 0xe2, 0x6c, 0xa3, 0xc3, 0x7d, + 0x63, 0x8c, 0x40, 0xd8, 0xe7, 0x50, 0xfa, 0x3c, 0x0d, 0x01, 0x14, 0xdd, 0x06, 0x08, 0x75, 0x0b, + 0x8a, 0x93, 0xb1, 0x3a, 0xf5, 0x18, 0xb9, 0xf6, 0xb9, 0x02, 0x97, 0xaa, 0x3d, 0x4c, 0xd8, 0x8e, + 0xeb, 0x34, 0x29, 0x73, 0x49, 0xe4, 0x66, 0x5c, 0x75, 0xdc, 0xe3, 0x0f, 0xa9, 0x85, 0x93, 0x75, + 0x4a, 0x36, 0x00, 0xcb, 0x32, 0xe5, 0x79, 0xc8, 0xb6, 0xfc, 0x08, 0x11, 0xe0, 0xf9, 0x8e, 0x9b, + 0x91, 0x50, 0x89, 0xd6, 0xff, 0x9c, 0x53, 0xa7, 0x0b, 0xd5, 0xb1, 0xdf, 0x05, 0xa6, 0xe5, 0x70, + 0x41, 0xfe, 0x2e, 0xf0, 0x5c, 0xdf, 0xdc, 0xd4, 0x77, 0xad, 0xf8, 0x64, 0x54, 0xfb, 0x44, 0x81, + 0xcb, 0x42, 0xdf, 0xe4, 0xf8, 0xcb, 0xaf, 0x24, 0x9f, 0xb2, 0x39, 0xb0, 0xf6, 0x53, 0x05, 0xae, + 0x26, 0x85, 0xdd, 0x8d, 0x54, 0x99, 0xac, 0xc8, 0xfd, 0x23, 0x67, 0x75, 0xcc, 0x91, 0xb3, 0xf6, + 0x6b, 0x05, 0x0a, 0x49, 0x59, 0xe3, 0x93, 0xd6, 0xc9, 0x0a, 0x3b, 0x30, 0xde, 0x56, 0x27, 0x30, + 0xde, 0xfe, 0x89, 0x02, 0xe7, 0x84, 0x02, 0x41, 0x7a, 0x9a, 0xac, 0xcc, 0x89, 0xf1, 0x9d, 0xfa, + 0x05, 0xc6, 0x77, 0x8f, 0x60, 0x39, 0x69, 0xe7, 0x68, 0x86, 0x77, 0xbf, 0xd3, 0x76, 0x4d, 0x6b, + 0x82, 0x93, 0x3c, 0xad, 0xd9, 0xff, 0x5a, 0xee, 0x46, 0x01, 0x77, 0x42, 0x96, 0xd1, 0xbe, 0xa7, + 0x40, 0x46, 0x1c, 0x12, 0xce, 0x05, 0x27, 0x64, 0xf2, 0x57, 0x61, 0x66, 0x8c, 0xe9, 0x95, 0xc4, + 0xd5, 0xbe, 0xaf, 0x40, 0x4e, 0x88, 0x13, 0x9b, 0xc9, 0xfd, 0x4f, 0x05, 0xfa, 0x83, 0x02, 0xcf, + 0x08, 0x81, 0x1a, 0xc9, 0xec, 0xba, 0xd9, 0xe9, 0xb4, 0x6d, 0x6c, 0x4d, 0x4a, 0xb8, 0xa1, 0x93, + 0xd3, 0x5b, 0x30, 0x4f, 0xf0, 0xa1, 0x71, 0xea, 0x91, 0x11, 0x10, 0x7c, 0x28, 0xbf, 0xd7, 0xff, + 0x38, 0x03, 0xe9, 0x77, 0xbb, 0xd8, 0x3b, 0x6a, 0x60, 0xaf, 0x67, 0xb7, 0x30, 0xfa, 0x48, 0x81, + 0x85, 0xfe, 0x66, 0x0e, 0x8d, 0xf0, 0x2b, 0xf6, 0x09, 0x2d, 0xe6, 0xd2, 0xc6, 0x69, 0x48, 0x65, + 0x51, 0xf8, 0xdd, 0x81, 0x5f, 0x04, 0xbe, 0x32, 0x6e, 0x1f, 0x26, 0xa5, 0x78, 0x6d, 0x6c, 0x3a, + 0x5f, 0x84, 0x57, 0x14, 0xf4, 0xa1, 0x32, 0xf8, 0x33, 0xe5, 0x57, 0xc7, 0x6f, 0xa1, 0xa4, 0x20, + 0xaf, 0x9f, 0x82, 0x52, 0x5a, 0x83, 0xdf, 0x4c, 0x7f, 0x1b, 0x83, 0xc6, 0xe1, 0x97, 0x6c, 0xd8, + 0x46, 0xb9, 0x99, 0x13, 0xbb, 0xa6, 0x1f, 0x28, 0xe1, 0x64, 0x23, 0xd1, 0x8b, 0xa0, 0xaf, 0x0d, + 0x67, 0xfa, 0x84, 0x4e, 0x69, 0xe9, 0xcd, 0xd3, 0x92, 0x4b, 0xb9, 0x12, 0x97, 0x25, 0x07, 0x3d, + 0xe3, 0x5c, 0x56, 0xa2, 0xed, 0x19, 0xeb, 0xb2, 0x92, 0xfd, 0x4c, 0xe9, 0xb7, 0xea, 0xef, 0x1e, + 0x2f, 0x2b, 0x9f, 0x3e, 0x5e, 0x56, 0xfe, 0xf6, 0x78, 0x59, 0xf9, 0xf8, 0xb3, 0xe5, 0x33, 0x9f, + 0x7e, 0xb6, 0x7c, 0xe6, 0xcf, 0x9f, 0x2d, 0x9f, 0x81, 0xeb, 0x2d, 0xd7, 0x19, 0xca, 0xb8, 0x04, + 0x7e, 0xe9, 0xe9, 0xb9, 0xcc, 0xad, 0x2b, 0x0f, 0x76, 0xf6, 0x6d, 0x76, 0xd0, 0x6d, 0x72, 0xc4, + 0xd5, 0x96, 0x4b, 0x1d, 0x97, 0xae, 0x7a, 0xbc, 0xd8, 0xc5, 0xde, 0x6a, 0x6f, 0x3d, 0xfc, 0x6c, + 0x1d, 0x98, 0x36, 0xa1, 0xab, 0xc3, 0xfe, 0x70, 0xeb, 0x0d, 0xf1, 0xd1, 0x5b, 0xfb, 0xb1, 0x9a, + 0xaa, 0x97, 0xcb, 0x8d, 0x4f, 0xd4, 0x42, 0x3d, 0x90, 0xa6, 0xcc, 0xa5, 0x29, 0x87, 0xd2, 0x08, + 0x19, 0x8a, 0xbb, 0x6b, 0xbf, 0x8f, 0x50, 0x1e, 0x72, 0x94, 0x87, 0x21, 0xca, 0x43, 0x81, 0xf2, + 0x70, 0x77, 0xed, 0xb1, 0x7a, 0x63, 0x18, 0xca, 0xc3, 0xad, 0x7a, 0xe9, 0x2e, 0x66, 0x26, 0xcf, + 0xbc, 0xff, 0x50, 0xaf, 0x07, 0xe8, 0x1b, 0x1b, 0x1c, 0x9f, 0xff, 0x2b, 0x09, 0x36, 0x36, 0x04, + 0xc5, 0xc6, 0xc6, 0xee, 0x5a, 0x73, 0x46, 0xfc, 0xb1, 0xd6, 0x97, 0xfe, 0x1d, 0x00, 0x00, 0xff, + 0xff, 0x32, 0xe5, 0x3b, 0x32, 0x8e, 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 +3356,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 +3386,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 +3406,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 +3480,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 +3490,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 +3527,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 +3566,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 +3587,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 +3601,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 +3636,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 +3664,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 +3684,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 +3696,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 +3718,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 +3728,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,7 +3760,250 @@ func (m *ValidatorDefinition) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintStake(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0xa + 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) { + 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 } @@ -4617,495 +5116,603 @@ 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() + if m.ToAddress != nil { + l = m.ToAddress.Size() n += 1 + l + sovStake(uint64(l)) } - if m.UnbondingAmount != nil { - l = m.UnbondingAmount.Size() - n += 1 + l + sovStake(uint64(l)) + return n +} +func (m *FundingStream_ToCommunityPool_) Size() (n int) { + if m == nil { + return 0 } - l = len(m.BalanceBlinding) - if l > 0 { + var l int + _ = l + if m.ToCommunityPool != nil { + l = m.ToCommunityPool.Size() n += 1 + l + sovStake(uint64(l)) } - l = len(m.ProofBlindingR) - if l > 0 { - n += 1 + l + sovStake(uint64(l)) + return n +} +func (m *FundingStream_ToAddress) Size() (n int) { + if m == nil { + return 0 } - l = len(m.ProofBlindingS) + var l int + _ = l + l = len(m.Address) if l > 0 { n += 1 + l + sovStake(uint64(l)) } - if m.UnbondingStartHeight != 0 { - n += 1 + sovStake(uint64(m.UnbondingStartHeight)) + if m.RateBps != 0 { + n += 1 + sovStake(uint64(m.RateBps)) } 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.RateBps != 0 { + n += 1 + sovStake(uint64(m.RateBps)) } return n } -func (m *Uptime) Size() (n int) { +func (m *RateData) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.AsOfBlockHeight != 0 { - n += 1 + sovStake(uint64(m.AsOfBlockHeight)) + if m.IdentityKey != nil { + l = m.IdentityKey.Size() + n += 1 + l + sovStake(uint64(l)) } - if m.WindowLen != 0 { - n += 1 + sovStake(uint64(m.WindowLen)) + if m.EpochIndex != 0 { + n += 1 + sovStake(uint64(m.EpochIndex)) } - l = len(m.Bitvec) - if l > 0 { + 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 *CurrentConsensusKeys) Size() (n int) { +func (m *BaseRateData) 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.EpochIndex != 0 { + n += 1 + sovStake(uint64(m.EpochIndex)) } - return n -} - -func (m *Penalty) Size() (n int) { - if m == nil { - return 0 + if m.BaseRewardRate != nil { + l = m.BaseRewardRate.Size() + n += 1 + l + sovStake(uint64(l)) } - var l int - _ = l - l = len(m.Inner) - if l > 0 { + if m.BaseExchangeRate != nil { + l = m.BaseExchangeRate.Size() n += 1 + l + sovStake(uint64(l)) } return n } -func (m *GetValidatorInfoRequest) Size() (n int) { +func (m *ValidatorStatus) Size() (n int) { if m == nil { return 0 } @@ -5115,74 +5722,370 @@ func (m *GetValidatorInfoRequest) Size() (n int) { 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 *GetValidatorInfoResponse) 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 *ValidatorInfoRequest) Size() (n int) { +func (m *ValidatorState) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.ShowInactive { - n += 2 + if m.State != 0 { + n += 1 + sovStake(uint64(m.State)) } return n } -func (m *ValidatorInfoResponse) Size() (n int) { +func (m *ValidatorInfo) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.ValidatorInfo != nil { - l = m.ValidatorInfo.Size() + 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 *ValidatorStatusRequest) 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)) + } + l = len(m.AuthSig) + if l > 0 { n += 1 + l + sovStake(uint64(l)) } return n } -func (m *ValidatorStatusResponse) Size() (n int) { +func (m *Delegate) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.Status != nil { - l = m.Status.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 *ValidatorPenaltyRequest) Size() (n int) { +func (m *Undelegate) 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.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 *UndelegateClaim) 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)) + } + return n +} + +func (m *UndelegateClaimBody) 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)) + } + return n +} + +func (m *UndelegateClaimPlan) 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 { + n += 1 + l + sovStake(uint64(l)) + } + if m.UnbondingStartHeight != 0 { + n += 1 + sovStake(uint64(m.UnbondingStartHeight)) + } + return n +} + +func (m *DelegationChanges) 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)) + } + } + return n +} + +func (m *Uptime) 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) + 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)) + } + } + 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)) + } + 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 *GetValidatorInfoResponse) 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 *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 } @@ -5319,42 +6222,599 @@ func (m *GenesisContent) Size() (n int) { n += 1 + l + sovStake(uint64(l)) } } - return n -} + 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 + } + } -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 +6837,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 +6857,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 +6898,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 +6921,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 +6956,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 +6976,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 +7077,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 +7093,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 +7162,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 +7246,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 +7267,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 +7301,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 +7337,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 +7365,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 +7388,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 +7442,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 +7478,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 +7506,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 +7529,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 +7549,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 +7585,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 +7657,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 +7700,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 +7723,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 +7743,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 +7762,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 +7781,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 +7850,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 +7876,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 +7899,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 +7919,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 +7970,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 +8006,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 +8034,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 +8057,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 +8092,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 +8113,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 +8154,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 +8177,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 +8197,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 +8233,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 +8288,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 +8331,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 +8354,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 +8374,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 +8444,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 +8480,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 +8516,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 +8544,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 +8567,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 +8602,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 +8638,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 +8664,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 +8687,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 +8731,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 +8743,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 +8777,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 +8813,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 +8860,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 +8883,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 +8973,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 +8994,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 +9030,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 +9064,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 +9098,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 +9158,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 +9181,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 +9216,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 +9235,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 +9276,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 +9299,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 +9319,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 +9338,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 +9357,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 +9456,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 +9482,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 +9505,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 +9525,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 +9624,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 +9695,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 +9738,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 +9761,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 +9781,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 +9866,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 +9894,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 +9917,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 +9937,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 +9980,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 +10003,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 +10038,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 +10066,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 +10089,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 +10164,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 +10190,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 +10213,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 +10248,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 +10276,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 +10299,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 +10334,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 +10362,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 +10385,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 +10405,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 +10448,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 +10471,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 +10506,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 +10534,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 +10557,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 +10592,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 +10620,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 +10643,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 +10811,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 +10858,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 +10881,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 +10916,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 +10937,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 +10978,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 +11001,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 +11074,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 +11155,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 +11178,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 +11220,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 +11249,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 +11277,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 +11300,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 +11342,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 +11399,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 +11422,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 +11457,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 +11521,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 +11544,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 +11564,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 +11600,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 +11701,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 +11772,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 +11815,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 +11838,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 +11873,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 +11909,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 +11937,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 +11960,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 +11980,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 +12016,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 +12124,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 +12138,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 +12157,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..3f096fe55 100644 --- a/relayer/chains/penumbra/view/v1/view.pb.go +++ b/relayer/chains/penumbra/view/v1/view.pb.go @@ -10,14 +10,15 @@ import ( types "github.com/cosmos/cosmos-sdk/codec/types" grpc1 "github.com/cosmos/gogoproto/grpc" proto "github.com/cosmos/gogoproto/proto" - v112 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/app/v1" + v113 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/app/v1" v18 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/asset/v1" v11 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/auction/v1" v12 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/dex/v1" v16 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/fee/v1" + v112 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/governance/v1" v15 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/ibc/v1" v17 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/sct/v1" - v113 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/shielded_pool/v1" + v114 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/shielded_pool/v1" v111 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/component/stake/v1" v1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/keys/v1" v110 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/num/v1" @@ -763,6 +764,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"` @@ -776,6 +778,7 @@ type TransactionPlannerRequest struct { DutchAuctionScheduleActions []*TransactionPlannerRequest_ActionDutchAuctionSchedule `protobuf:"bytes,73,rep,name=dutch_auction_schedule_actions,json=dutchAuctionScheduleActions,proto3" json:"dutch_auction_schedule_actions,omitempty"` DutchAuctionEndActions []*TransactionPlannerRequest_ActionDutchAuctionEnd `protobuf:"bytes,74,rep,name=dutch_auction_end_actions,json=dutchAuctionEndActions,proto3" json:"dutch_auction_end_actions,omitempty"` DutchAuctionWithdrawActions []*TransactionPlannerRequest_ActionDutchAuctionWithdraw `protobuf:"bytes,75,rep,name=dutch_auction_withdraw_actions,json=dutchAuctionWithdrawActions,proto3" json:"dutch_auction_withdraw_actions,omitempty"` + DelegatorVotes []*TransactionPlannerRequest_DelegatorVote `protobuf:"bytes,76,rep,name=delegator_votes,json=delegatorVotes,proto3" json:"delegator_votes,omitempty"` // Specifies either that the planner should compute fees automatically or that it should use a fixed fee amount. // // Types that are valid to be assigned to FeeMode: @@ -872,6 +875,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 @@ -963,6 +973,13 @@ func (m *TransactionPlannerRequest) GetDutchAuctionWithdrawActions() []*Transact return nil } +func (m *TransactionPlannerRequest) GetDelegatorVotes() []*TransactionPlannerRequest_DelegatorVote { + if m != nil { + return m.DelegatorVotes + } + return nil +} + func (m *TransactionPlannerRequest) GetAutoFee() *v16.FeeTier { if x, ok := m.GetFeeMode().(*TransactionPlannerRequest_AutoFee); ok { return x.AutoFee @@ -1055,6 +1072,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 +1141,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 +1209,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 +1254,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 +1306,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 +1372,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 +1451,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 +1498,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 +1551,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 +1614,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 +1663,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 +1714,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) @@ -1686,6 +1757,89 @@ func (m *TransactionPlannerRequest_ActionDutchAuctionWithdraw) GetSeq() uint64 { return 0 } +type TransactionPlannerRequest_DelegatorVote struct { + // The proposal being voted on. + Proposal uint64 `protobuf:"varint,1,opt,name=proposal,proto3" json:"proposal,omitempty"` + // The vote. + Vote *v112.Vote `protobuf:"bytes,2,opt,name=vote,proto3" json:"vote,omitempty"` + // The block height at which the proposal started voting. + StartBlockHeight uint64 `protobuf:"varint,3,opt,name=start_block_height,json=startBlockHeight,proto3" json:"start_block_height,omitempty"` + // The position of the state commitment tree at which the proposal is considered to have started voting. + StartPosition uint64 `protobuf:"varint,4,opt,name=start_position,json=startPosition,proto3" json:"start_position,omitempty"` + // The validators rate data for the proposal. + RateData []*v111.RateData `protobuf:"bytes,5,rep,name=rate_data,json=rateData,proto3" json:"rate_data,omitempty"` +} + +func (m *TransactionPlannerRequest_DelegatorVote) Reset() { + *m = TransactionPlannerRequest_DelegatorVote{} +} +func (m *TransactionPlannerRequest_DelegatorVote) String() string { return proto.CompactTextString(m) } +func (*TransactionPlannerRequest_DelegatorVote) ProtoMessage() {} +func (*TransactionPlannerRequest_DelegatorVote) Descriptor() ([]byte, []int) { + return fileDescriptor_dba93d04e42ddfc3, []int{6, 13} +} +func (m *TransactionPlannerRequest_DelegatorVote) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TransactionPlannerRequest_DelegatorVote) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TransactionPlannerRequest_DelegatorVote.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_DelegatorVote) XXX_Merge(src proto.Message) { + xxx_messageInfo_TransactionPlannerRequest_DelegatorVote.Merge(m, src) +} +func (m *TransactionPlannerRequest_DelegatorVote) XXX_Size() int { + return m.Size() +} +func (m *TransactionPlannerRequest_DelegatorVote) XXX_DiscardUnknown() { + xxx_messageInfo_TransactionPlannerRequest_DelegatorVote.DiscardUnknown(m) +} + +var xxx_messageInfo_TransactionPlannerRequest_DelegatorVote proto.InternalMessageInfo + +func (m *TransactionPlannerRequest_DelegatorVote) GetProposal() uint64 { + if m != nil { + return m.Proposal + } + return 0 +} + +func (m *TransactionPlannerRequest_DelegatorVote) GetVote() *v112.Vote { + if m != nil { + return m.Vote + } + return nil +} + +func (m *TransactionPlannerRequest_DelegatorVote) GetStartBlockHeight() uint64 { + if m != nil { + return m.StartBlockHeight + } + return 0 +} + +func (m *TransactionPlannerRequest_DelegatorVote) GetStartPosition() uint64 { + if m != nil { + return m.StartPosition + } + return 0 +} + +func (m *TransactionPlannerRequest_DelegatorVote) GetRateData() []*v111.RateData { + if m != nil { + return m.RateData + } + return nil +} + type TransactionPlannerResponse struct { Plan *v13.TransactionPlan `protobuf:"bytes,1,opt,name=plan,proto3" json:"plan,omitempty"` } @@ -2684,6 +2838,7 @@ func (m *WitnessAndBuildRequest) GetAuthorizationData() *v13.AuthorizationData { type WitnessAndBuildResponse struct { // Types that are valid to be assigned to Status: + // // *WitnessAndBuildResponse_BuildProgress_ // *WitnessAndBuildResponse_Complete_ Status isWitnessAndBuildResponse_Status `protobuf_oneof:"status"` @@ -3043,7 +3198,7 @@ func (m *AppParametersRequest) XXX_DiscardUnknown() { var xxx_messageInfo_AppParametersRequest proto.InternalMessageInfo type AppParametersResponse struct { - Parameters *v112.AppParameters `protobuf:"bytes,1,opt,name=parameters,proto3" json:"parameters,omitempty"` + Parameters *v113.AppParameters `protobuf:"bytes,1,opt,name=parameters,proto3" json:"parameters,omitempty"` } func (m *AppParametersResponse) Reset() { *m = AppParametersResponse{} } @@ -3079,7 +3234,7 @@ func (m *AppParametersResponse) XXX_DiscardUnknown() { var xxx_messageInfo_AppParametersResponse proto.InternalMessageInfo -func (m *AppParametersResponse) GetParameters() *v112.AppParameters { +func (m *AppParametersResponse) GetParameters() *v113.AppParameters { if m != nil { return m.Parameters } @@ -3215,7 +3370,7 @@ func (m *FMDParametersRequest) XXX_DiscardUnknown() { var xxx_messageInfo_FMDParametersRequest proto.InternalMessageInfo type FMDParametersResponse struct { - Parameters *v113.FmdParameters `protobuf:"bytes,1,opt,name=parameters,proto3" json:"parameters,omitempty"` + Parameters *v114.FmdParameters `protobuf:"bytes,1,opt,name=parameters,proto3" json:"parameters,omitempty"` } func (m *FMDParametersResponse) Reset() { *m = FMDParametersResponse{} } @@ -3251,7 +3406,7 @@ func (m *FMDParametersResponse) XXX_DiscardUnknown() { var xxx_messageInfo_FMDParametersResponse proto.InternalMessageInfo -func (m *FMDParametersResponse) GetParameters() *v113.FmdParameters { +func (m *FMDParametersResponse) GetParameters() *v114.FmdParameters { if m != nil { return m.Parameters } @@ -3997,7 +4152,7 @@ type SpendableNoteRecord struct { // The note commitment, identifying the note. NoteCommitment *v19.StateCommitment `protobuf:"bytes,1,opt,name=note_commitment,json=noteCommitment,proto3" json:"note_commitment,omitempty"` // The note plaintext itself. - Note *v113.Note `protobuf:"bytes,2,opt,name=note,proto3" json:"note,omitempty"` + Note *v114.Note `protobuf:"bytes,2,opt,name=note,proto3" json:"note,omitempty"` // A precomputed decryption of the note's address incore.component.dex.v1. AddressIndex *v1.AddressIndex `protobuf:"bytes,3,opt,name=address_index,json=addressIndex,proto3" json:"address_index,omitempty"` // The note's nullifier. @@ -4054,7 +4209,7 @@ func (m *SpendableNoteRecord) GetNoteCommitment() *v19.StateCommitment { return nil } -func (m *SpendableNoteRecord) GetNote() *v113.Note { +func (m *SpendableNoteRecord) GetNote() *v114.Note { if m != nil { return m.Note } @@ -4624,6 +4779,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") @@ -4635,6 +4791,7 @@ func init() { proto.RegisterType((*TransactionPlannerRequest_ActionDutchAuctionSchedule)(nil), "penumbra.view.v1.TransactionPlannerRequest.ActionDutchAuctionSchedule") proto.RegisterType((*TransactionPlannerRequest_ActionDutchAuctionEnd)(nil), "penumbra.view.v1.TransactionPlannerRequest.ActionDutchAuctionEnd") proto.RegisterType((*TransactionPlannerRequest_ActionDutchAuctionWithdraw)(nil), "penumbra.view.v1.TransactionPlannerRequest.ActionDutchAuctionWithdraw") + proto.RegisterType((*TransactionPlannerRequest_DelegatorVote)(nil), "penumbra.view.v1.TransactionPlannerRequest.DelegatorVote") proto.RegisterType((*TransactionPlannerResponse)(nil), "penumbra.view.v1.TransactionPlannerResponse") proto.RegisterType((*AddressByIndexRequest)(nil), "penumbra.view.v1.AddressByIndexRequest") proto.RegisterType((*AddressByIndexResponse)(nil), "penumbra.view.v1.AddressByIndexResponse") @@ -4696,279 +4853,288 @@ func init() { func init() { proto.RegisterFile("penumbra/view/v1/view.proto", fileDescriptor_dba93d04e42ddfc3) } var fileDescriptor_dba93d04e42ddfc3 = []byte{ - // 4352 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, - 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, - 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, + // 4490 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x3c, 0x49, 0x6c, 0xdc, 0x58, + 0x76, 0x66, 0x49, 0x96, 0x4a, 0x4f, 0xaa, 0x45, 0xbf, 0x2d, 0xb9, 0x5c, 0xed, 0x96, 0x6d, 0xf6, + 0x26, 0xdb, 0x3d, 0xa5, 0xc5, 0x3d, 0xbd, 0xd8, 0x6e, 0x4c, 0xaa, 0xb4, 0x58, 0xb2, 0x65, 0x59, + 0x4d, 0xc9, 0x72, 0x4f, 0x8f, 0x3b, 0x0c, 0x8b, 0xfc, 0x92, 0x18, 0xb3, 0x48, 0x9a, 0x64, 0x95, + 0xac, 0x64, 0xce, 0x09, 0xd2, 0x83, 0x00, 0x41, 0x26, 0xd7, 0x24, 0x40, 0x80, 0x49, 0x80, 0x04, + 0xe8, 0x7b, 0x4e, 0xb9, 0xce, 0x04, 0x08, 0x30, 0xc8, 0xa9, 0x2f, 0x01, 0x06, 0xdd, 0xb7, 0xdc, + 0x73, 0xca, 0x21, 0xc1, 0xdf, 0x58, 0x24, 0x8b, 0x54, 0x55, 0xc9, 0x9a, 0x01, 0xe6, 0x24, 0xfe, + 0xf7, 0xdf, 0xf6, 0xdf, 0xdf, 0xde, 0xf2, 0x4b, 0xf0, 0xa6, 0x8b, 0xed, 0x76, 0xab, 0xe9, 0x69, + 0x0b, 0x1d, 0x13, 0x1f, 0x2f, 0x74, 0x96, 0xe8, 0xdf, 0x9a, 0xeb, 0x39, 0x81, 0x83, 0xca, 0xa2, + 0xb3, 0x46, 0x81, 0x9d, 0xa5, 0xea, 0x95, 0x43, 0xc7, 0x39, 0xb4, 0xf0, 0x02, 0xed, 0x6f, 0xb6, + 0x0f, 0x16, 0x34, 0xfb, 0x84, 0x21, 0x57, 0xe7, 0x42, 0x4e, 0xba, 0xe3, 0xe1, 0x05, 0xcd, 0x75, + 0x09, 0x37, 0xcd, 0x75, 0x79, 0xbf, 0x9c, 0xe8, 0xf7, 0x7d, 0x1c, 0x50, 0x0c, 0xf2, 0xc1, 0x71, + 0x16, 0xe3, 0x38, 0xba, 0xd3, 0x72, 0x1d, 0x1b, 0xdb, 0xc1, 0x82, 0xd6, 0xd6, 0x03, 0xd3, 0xb1, + 0x29, 0x3e, 0xfb, 0xe4, 0x14, 0xf3, 0x59, 0x14, 0x06, 0x7e, 0x45, 0xb0, 0x0d, 0xfc, 0xaa, 0x1f, + 0xe6, 0x01, 0xc6, 0x04, 0xf3, 0x00, 0x63, 0x8e, 0xf9, 0x51, 0x16, 0xe6, 0xa1, 0xd3, 0xc1, 0x9e, + 0xad, 0xd9, 0x3a, 0x25, 0xe8, 0xb6, 0xfa, 0x49, 0x30, 0x9b, 0x3a, 0x21, 0x30, 0x9b, 0x7a, 0x3f, + 0x4c, 0x5f, 0xa7, 0x36, 0xf1, 0x75, 0x61, 0x91, 0xfb, 0x99, 0x98, 0x47, 0x26, 0xb6, 0x0c, 0x6c, + 0xa8, 0xae, 0xe3, 0x58, 0x94, 0x26, 0x0a, 0xe0, 0xd4, 0x1f, 0x64, 0x52, 0x07, 0xda, 0x0b, 0x3a, + 0x08, 0xfa, 0xc1, 0xb1, 0xaf, 0xc7, 0xb1, 0x5f, 0xe0, 0x13, 0x9f, 0xa0, 0x90, 0xbf, 0xe9, 0x73, + 0x6c, 0xb7, 0x5b, 0x04, 0xc1, 0x6e, 0xb7, 0x78, 0x7f, 0x2d, 0xde, 0x1f, 0x78, 0x9a, 0xed, 0x6b, + 0xe1, 0xcc, 0x45, 0x9a, 0x1c, 0xff, 0x9d, 0x04, 0xfe, 0xab, 0x23, 0xcd, 0x3f, 0xa2, 0xa8, 0xf4, + 0xab, 0x57, 0x2f, 0xef, 0xc4, 0x0d, 0x9c, 0x85, 0x80, 0x59, 0x29, 0x10, 0x56, 0x92, 0x7f, 0x9e, + 0x83, 0x52, 0x9d, 0xad, 0x0b, 0x5f, 0xc1, 0x2f, 0xdb, 0xd8, 0x0f, 0xd0, 0x43, 0x28, 0x6a, 0xba, + 0xee, 0xb4, 0xed, 0x40, 0x3d, 0x30, 0xad, 0x00, 0x7b, 0x15, 0xe9, 0xba, 0x34, 0x3f, 0xb9, 0xfc, + 0x76, 0xa8, 0x64, 0x8d, 0x08, 0xad, 0xd1, 0xe1, 0x75, 0x96, 0x6a, 0x75, 0xc3, 0xf0, 0xb0, 0xef, + 0x6f, 0xda, 0x06, 0x7e, 0xa5, 0x14, 0x38, 0xe9, 0x3a, 0xa5, 0x44, 0x37, 0xa1, 0x6c, 0xda, 0xba, + 0xd5, 0x36, 0xb0, 0x6a, 0xda, 0x64, 0x04, 0x1d, 0x5c, 0xc9, 0x5d, 0x97, 0xe6, 0xf3, 0x4a, 0x89, + 0xc3, 0x37, 0x39, 0x18, 0x7d, 0x00, 0xe8, 0x65, 0x1b, 0x7b, 0x27, 0xaa, 0xa5, 0x05, 0xd8, 0x0f, + 0x54, 0x3f, 0xd0, 0x02, 0x5c, 0x19, 0xa1, 0xc8, 0x65, 0xda, 0xb3, 0x45, 0x3b, 0x76, 0x09, 0x1c, + 0xfd, 0x04, 0x10, 0x5f, 0xcf, 0xaa, 0x69, 0xf8, 0x42, 0xd1, 0xd1, 0xeb, 0x23, 0xf3, 0x93, 0xcb, + 0x3f, 0x48, 0x28, 0x1a, 0xce, 0x5e, 0x4d, 0x6c, 0x01, 0xa2, 0x35, 0xfb, 0xdc, 0x34, 0x94, 0xb2, + 0x26, 0x3e, 0x7d, 0xa6, 0xb5, 0xfc, 0x4d, 0x0e, 0xca, 0x5d, 0xab, 0xf8, 0xae, 0x63, 0xfb, 0x18, + 0x7d, 0x06, 0x39, 0xd3, 0xe0, 0xa6, 0x18, 0x52, 0x42, 0xce, 0x34, 0x50, 0x0d, 0xc6, 0x79, 0x1f, + 0x35, 0xc0, 0xe4, 0xf2, 0xa5, 0x1a, 0x3b, 0x12, 0x6a, 0xe2, 0x48, 0xa8, 0xd5, 0xed, 0x13, 0x45, + 0x20, 0xa1, 0x75, 0x98, 0x70, 0x1d, 0xdf, 0xa4, 0x3a, 0x54, 0x46, 0xe8, 0xb8, 0xe6, 0x33, 0xa5, + 0x92, 0xcd, 0xda, 0x59, 0xaa, 0xed, 0x70, 0x02, 0xa5, 0x4b, 0x8a, 0xd6, 0x61, 0xd2, 0x76, 0x02, + 0xac, 0x7a, 0x58, 0x77, 0x3c, 0xa3, 0x32, 0x4a, 0x65, 0xbf, 0x5b, 0x4b, 0x1e, 0x50, 0xb5, 0x5d, + 0x17, 0xdb, 0x86, 0xd6, 0xb4, 0xf0, 0xb6, 0x13, 0x60, 0x85, 0x22, 0x2b, 0x60, 0x87, 0xdf, 0xe8, + 0x4d, 0x98, 0xb0, 0x1c, 0x5d, 0xb3, 0x54, 0x1f, 0xbf, 0xac, 0x5c, 0xbc, 0x2e, 0xcd, 0x8f, 0x2a, + 0x79, 0x0a, 0xd8, 0xc5, 0x2f, 0xe5, 0x00, 0x2a, 0xf5, 0x76, 0x70, 0xe4, 0x78, 0xe6, 0x9f, 0xe0, + 0xba, 0x6d, 0x34, 0xda, 0xa6, 0x65, 0x88, 0xe5, 0xf4, 0x05, 0x94, 0x23, 0xeb, 0x57, 0x75, 0x2d, + 0xcd, 0xce, 0xb0, 0x62, 0x74, 0x99, 0x77, 0x96, 0x6a, 0x7b, 0xdd, 0xe6, 0x8e, 0xa5, 0xd9, 0x4a, + 0x29, 0x88, 0x03, 0xe4, 0xef, 0x73, 0x70, 0x25, 0x45, 0x2c, 0x9f, 0xaf, 0x26, 0x14, 0x9b, 0x04, + 0xa0, 0xba, 0x9e, 0x73, 0x48, 0x16, 0x28, 0x97, 0xfa, 0x69, 0xef, 0xd8, 0x33, 0x99, 0xd4, 0x68, + 0x6b, 0x87, 0x33, 0xd8, 0xb8, 0xa0, 0x14, 0x9a, 0x51, 0x00, 0x52, 0x20, 0x4f, 0x26, 0xc1, 0xc2, + 0x01, 0xe6, 0xb3, 0xfa, 0xe1, 0x30, 0xdc, 0x57, 0x38, 0xed, 0xc6, 0x05, 0x25, 0xe4, 0x53, 0xbd, + 0x0d, 0x85, 0x98, 0x54, 0x54, 0x85, 0x7c, 0x6c, 0x08, 0x39, 0x25, 0x6c, 0x57, 0x9f, 0x41, 0x5e, + 0x30, 0x41, 0x8f, 0x60, 0x32, 0x62, 0x21, 0x3e, 0xda, 0x9b, 0x03, 0xdb, 0x58, 0x89, 0x52, 0x37, + 0xf2, 0x30, 0x46, 0x36, 0x60, 0xdb, 0x97, 0x7f, 0x2e, 0xc1, 0x9b, 0x0d, 0xcf, 0xd1, 0x0c, 0x5d, + 0xf3, 0x83, 0x28, 0x3e, 0x9f, 0xdf, 0xf3, 0x14, 0x8b, 0xde, 0x87, 0x92, 0x76, 0xac, 0x99, 0x81, + 0x6a, 0xe0, 0x00, 0x77, 0x77, 0x4b, 0x5e, 0x29, 0x52, 0xf0, 0xaa, 0x80, 0xca, 0xdf, 0x8c, 0xc0, + 0xd5, 0x74, 0xad, 0xf8, 0xf4, 0xdb, 0x30, 0xdd, 0x14, 0xfd, 0xaa, 0xdf, 0xd6, 0xf5, 0xee, 0x0a, + 0xf8, 0x51, 0xef, 0x1c, 0x9d, 0xc6, 0xaa, 0xdb, 0xb9, 0xcb, 0xd8, 0x6c, 0x5c, 0x50, 0xca, 0xcd, + 0x04, 0x0c, 0x7d, 0x01, 0x13, 0xba, 0x63, 0x1f, 0x98, 0x5e, 0x0b, 0x1b, 0x7c, 0x2d, 0x7c, 0x32, + 0xa4, 0x9c, 0x15, 0x41, 0xbf, 0x71, 0x41, 0xe9, 0x32, 0xab, 0x3e, 0x84, 0x72, 0x52, 0x03, 0xf4, + 0x51, 0xe4, 0x30, 0x7a, 0x2f, 0x69, 0x6b, 0x76, 0x05, 0xc4, 0xcd, 0xcc, 0x4e, 0xa1, 0xaa, 0x0d, + 0x13, 0xa1, 0x94, 0xb3, 0x32, 0x21, 0x87, 0x7a, 0x38, 0x3d, 0xea, 0x11, 0x36, 0x0f, 0x8f, 0x02, + 0x3a, 0xe2, 0x51, 0xa5, 0x14, 0xc2, 0x37, 0x28, 0x38, 0xb2, 0x8c, 0xbe, 0xbd, 0x01, 0x57, 0x12, + 0x3b, 0xda, 0xc6, 0x9e, 0x58, 0x44, 0x6f, 0x43, 0x01, 0xbf, 0x72, 0x4d, 0xef, 0x44, 0xf0, 0x93, + 0x28, 0xbf, 0x29, 0x06, 0x64, 0xcc, 0xd0, 0x8f, 0x60, 0xb4, 0x85, 0x5b, 0x0e, 0xbd, 0x13, 0x26, + 0x97, 0x6f, 0x9f, 0xbe, 0xc4, 0x1e, 0xe3, 0x96, 0xb3, 0x63, 0x69, 0xa6, 0x1d, 0xe0, 0x57, 0x81, + 0x42, 0x09, 0xd1, 0x3d, 0x18, 0xf3, 0x9d, 0xb6, 0xa7, 0x63, 0x7e, 0x0c, 0x0e, 0x74, 0xa3, 0x71, + 0x12, 0xb4, 0x05, 0xe3, 0x4e, 0x3b, 0x70, 0xdb, 0x81, 0x5f, 0xb9, 0x44, 0x8f, 0xe3, 0xe5, 0xde, + 0xe9, 0xcd, 0x1c, 0x60, 0xed, 0x09, 0x25, 0x55, 0x04, 0x0b, 0xb4, 0x09, 0x63, 0x3e, 0x39, 0x71, + 0xfd, 0xca, 0x0c, 0x65, 0xb6, 0x34, 0x0c, 0x33, 0x7a, 0x56, 0x2b, 0x9c, 0x01, 0x5a, 0x87, 0x8b, + 0xfe, 0xb1, 0xe6, 0xfa, 0x95, 0x39, 0xca, 0x69, 0x71, 0x28, 0x4e, 0xc7, 0x9a, 0xab, 0x30, 0x72, + 0xb4, 0x0f, 0x93, 0xe4, 0x43, 0xd5, 0x2d, 0xcd, 0x6c, 0xf9, 0x95, 0x6b, 0x94, 0xdb, 0x0f, 0x87, + 0xe5, 0xb6, 0x42, 0xa8, 0x15, 0xf0, 0xc5, 0x27, 0xe5, 0x6b, 0x60, 0x0b, 0x1f, 0x6a, 0xec, 0x2e, + 0x9b, 0xa7, 0x7c, 0x3f, 0x1c, 0x86, 0xef, 0x2a, 0x23, 0xc7, 0x4a, 0x94, 0x11, 0x7a, 0x0e, 0x85, + 0xb6, 0x1d, 0xe5, 0xbc, 0x4c, 0x39, 0x7f, 0x34, 0x0c, 0xe7, 0xa7, 0x82, 0x01, 0x56, 0xe2, 0xcc, + 0x90, 0x05, 0x6f, 0x44, 0x01, 0xc2, 0x2a, 0x77, 0xa8, 0x8c, 0x7b, 0x67, 0x93, 0xc1, 0x6c, 0x83, + 0xa2, 0x7c, 0xb9, 0x8d, 0xf6, 0x60, 0xda, 0x6c, 0xea, 0xaa, 0x87, 0x2d, 0xed, 0x44, 0x65, 0x5c, + 0xfc, 0xca, 0xfd, 0x3e, 0xb7, 0x3e, 0x71, 0x8b, 0x3b, 0x4b, 0xb5, 0xcd, 0xa6, 0xae, 0x10, 0x3a, + 0xa5, 0x64, 0xf2, 0xaf, 0xba, 0x2e, 0x2c, 0x34, 0x6d, 0xea, 0xfe, 0xf2, 0xa2, 0x7a, 0x6c, 0x06, + 0x47, 0x86, 0xa7, 0x1d, 0x6b, 0x96, 0x5f, 0xf9, 0x8c, 0x72, 0x5d, 0xe8, 0xcb, 0x95, 0x10, 0x3e, + 0x0b, 0xe9, 0x94, 0xb2, 0x19, 0x07, 0xf8, 0x48, 0x85, 0xa2, 0x70, 0x33, 0x54, 0xc7, 0xc5, 0xb6, + 0x5f, 0x59, 0xa7, 0xac, 0x3f, 0x19, 0xc6, 0x38, 0xc2, 0x65, 0x79, 0xe2, 0x62, 0x5b, 0x29, 0xb8, + 0x91, 0x96, 0x8f, 0x9a, 0x50, 0x0a, 0x05, 0xe8, 0x96, 0xe3, 0x63, 0xbf, 0xf2, 0x80, 0x4a, 0xf8, + 0xf4, 0x2c, 0x12, 0x56, 0x08, 0x07, 0x25, 0x54, 0x99, 0x36, 0x7d, 0xf4, 0x02, 0x50, 0x28, 0x43, + 0x58, 0xc9, 0xaf, 0x6c, 0x50, 0x31, 0xf7, 0xcf, 0x22, 0x46, 0x58, 0x48, 0x99, 0x76, 0x13, 0x10, + 0x1f, 0xfd, 0x4c, 0x82, 0x39, 0xa3, 0x1d, 0xe8, 0x47, 0xaa, 0xf0, 0x5d, 0x7d, 0xfd, 0x08, 0x1b, + 0x6d, 0x0b, 0x87, 0x73, 0xbe, 0x49, 0x25, 0xaf, 0x0f, 0x23, 0x99, 0xcd, 0xf6, 0x2a, 0xe1, 0xcb, + 0x5d, 0xce, 0x5d, 0xce, 0x55, 0x79, 0xd3, 0x48, 0x81, 0x8a, 0xd5, 0xf1, 0x53, 0xb8, 0x12, 0x57, + 0x06, 0xdb, 0x46, 0xa8, 0xc7, 0x43, 0xaa, 0x47, 0xfd, 0xf5, 0xf4, 0x58, 0xb3, 0x0d, 0x65, 0xd6, + 0x88, 0x03, 0x84, 0xf4, 0x5e, 0x5b, 0x08, 0xf3, 0x87, 0x3a, 0x3c, 0x3a, 0x0f, 0x5b, 0x84, 0xf3, + 0x11, 0xb3, 0x85, 0x80, 0x0a, 0x6d, 0x9a, 0x50, 0xe2, 0x7b, 0xd2, 0xf1, 0xd4, 0x8e, 0x13, 0x60, + 0xbf, 0xb2, 0x35, 0xfc, 0x52, 0x5b, 0x15, 0x2c, 0xf6, 0x89, 0xdf, 0x5c, 0x34, 0xa2, 0x4d, 0x1f, + 0xad, 0x42, 0x5e, 0x6b, 0x07, 0x8e, 0x7a, 0x80, 0x71, 0xc5, 0xa0, 0xf7, 0xcf, 0xfb, 0x99, 0x9b, + 0x90, 0xc4, 0xd4, 0x9d, 0xa5, 0xda, 0x3a, 0xc6, 0x7b, 0x26, 0xf6, 0x36, 0x2e, 0x90, 0xb8, 0x20, + 0x70, 0xd6, 0x31, 0x46, 0xab, 0x00, 0x2d, 0xcd, 0x6e, 0x6b, 0x16, 0xe5, 0x83, 0x53, 0xef, 0xb1, + 0x34, 0x3e, 0xc4, 0xa7, 0x60, 0x84, 0x84, 0xcb, 0x3b, 0x30, 0x89, 0x5d, 0x47, 0x3f, 0x52, 0x4d, + 0x72, 0xc7, 0x55, 0x7e, 0x49, 0xaf, 0xdb, 0x46, 0xae, 0x22, 0x29, 0x40, 0xe1, 0xf4, 0xea, 0x43, + 0xf7, 0xe1, 0x22, 0x6d, 0x55, 0x7e, 0x25, 0x25, 0xc3, 0x86, 0x84, 0x1c, 0x12, 0x77, 0x77, 0x96, + 0x6a, 0x6b, 0x04, 0x5b, 0x61, 0x44, 0xd5, 0x63, 0x18, 0x63, 0xb7, 0x1e, 0xba, 0x03, 0x17, 0x3b, + 0x9a, 0xd5, 0xc6, 0xdc, 0xd7, 0x78, 0x2b, 0xc1, 0x86, 0x25, 0x32, 0x3a, 0x4b, 0xb5, 0x7d, 0x82, + 0xa4, 0x30, 0x5c, 0xf4, 0x09, 0x8c, 0x6b, 0xec, 0x1e, 0xe6, 0xee, 0xd4, 0xdc, 0xe9, 0xb7, 0xb5, + 0x22, 0xd0, 0xab, 0x1d, 0xb8, 0x48, 0x6f, 0xc8, 0xdf, 0xb5, 0xdc, 0xff, 0x95, 0x60, 0x94, 0x5c, + 0x81, 0x67, 0x93, 0xdb, 0x80, 0xa9, 0x40, 0xf3, 0x0e, 0x71, 0xa0, 0xd2, 0x7e, 0x2e, 0xfc, 0x5a, + 0x16, 0x6d, 0x9d, 0x7c, 0x6c, 0x1a, 0xca, 0x24, 0x23, 0xa2, 0x4d, 0xf4, 0x43, 0x18, 0x21, 0xab, + 0x62, 0x64, 0xe0, 0x55, 0xa1, 0x10, 0x7c, 0xb4, 0x02, 0x05, 0x7a, 0xbd, 0xa9, 0x62, 0xe0, 0xa3, + 0x03, 0x0d, 0x7c, 0x8a, 0x12, 0xf1, 0x56, 0xf5, 0x2b, 0x98, 0x08, 0xef, 0x7f, 0xb4, 0x03, 0x25, + 0xe6, 0x4b, 0x38, 0xad, 0x96, 0x19, 0xb4, 0xb0, 0x1d, 0x70, 0x5b, 0x44, 0x97, 0x3c, 0xcd, 0x49, + 0xd4, 0x02, 0xb6, 0x74, 0x68, 0x58, 0xbf, 0x12, 0xa2, 0x2b, 0x45, 0xea, 0x41, 0x84, 0xed, 0xea, + 0x5f, 0x48, 0x90, 0x17, 0x7e, 0x00, 0xfa, 0x10, 0xc6, 0xb4, 0x96, 0xd3, 0x0e, 0xb9, 0x5e, 0x4d, + 0x68, 0x6a, 0xb7, 0x5b, 0x54, 0x51, 0x8a, 0xa3, 0x70, 0x5c, 0xf4, 0x00, 0x26, 0x3c, 0x2d, 0xc0, + 0xaa, 0xa1, 0x05, 0x1a, 0xb7, 0xd1, 0xad, 0xec, 0x15, 0x4d, 0xf3, 0x3b, 0x9d, 0xa5, 0x9a, 0xa2, + 0x05, 0x78, 0x55, 0x0b, 0x34, 0x25, 0xef, 0xf1, 0xaf, 0xea, 0xd7, 0x12, 0x40, 0xf7, 0x56, 0x3f, + 0xdb, 0x74, 0xc7, 0x94, 0xc9, 0xbd, 0x86, 0x32, 0xdf, 0xe6, 0xa0, 0x94, 0x70, 0x31, 0xd0, 0xe7, + 0x80, 0x3a, 0x9a, 0x65, 0x1a, 0xf4, 0x38, 0x33, 0x0d, 0x6c, 0x07, 0x66, 0x70, 0xc2, 0xd5, 0x93, + 0x33, 0x66, 0x75, 0x93, 0xa3, 0x3d, 0xc2, 0x27, 0xca, 0x74, 0x48, 0x2d, 0xa0, 0xa8, 0x06, 0xd3, + 0x7e, 0xa0, 0x79, 0x81, 0x1a, 0x3d, 0x37, 0x72, 0xe1, 0xb1, 0x51, 0xa2, 0x9d, 0x6b, 0xdd, 0xb3, + 0x63, 0x05, 0xc6, 0x5d, 0x6c, 0x6b, 0x56, 0x70, 0xc2, 0x4d, 0x7d, 0xb3, 0xff, 0xe8, 0x76, 0x18, + 0x81, 0x22, 0x28, 0xd1, 0x03, 0x28, 0xb7, 0xed, 0xa6, 0x63, 0x1b, 0xa6, 0x7d, 0xa8, 0xf2, 0x19, + 0x1f, 0x1d, 0x60, 0xc6, 0x4b, 0x21, 0x15, 0x03, 0xa0, 0x0f, 0x61, 0xb6, 0xcb, 0x88, 0x8d, 0x83, + 0x07, 0x1a, 0x2c, 0x95, 0x71, 0x29, 0xec, 0xdd, 0x25, 0x9d, 0x2c, 0xe0, 0xa8, 0xee, 0xc1, 0x54, + 0xd4, 0x3f, 0x21, 0x27, 0xb8, 0xb8, 0xd4, 0xb9, 0x31, 0x07, 0x4f, 0xc9, 0x84, 0x94, 0xd5, 0xe7, + 0x50, 0x88, 0xf9, 0x24, 0x24, 0x82, 0x0e, 0x7d, 0x90, 0x30, 0x20, 0xbb, 0x35, 0x28, 0xe7, 0x4d, + 0x43, 0x01, 0x37, 0xfc, 0xae, 0xfe, 0x8f, 0x04, 0xe5, 0xa4, 0x2f, 0x72, 0xae, 0x12, 0x88, 0x15, + 0x3c, 0xec, 0x63, 0xaf, 0x83, 0xc5, 0x09, 0xd9, 0xd7, 0x0a, 0x0a, 0xc7, 0x57, 0x42, 0x4a, 0xb4, + 0x0d, 0x53, 0x81, 0xa7, 0xd1, 0xf9, 0x70, 0x35, 0xd3, 0xcb, 0x08, 0xea, 0x7a, 0x38, 0xed, 0x31, + 0x9a, 0x1d, 0xcd, 0xf4, 0x68, 0xe6, 0x40, 0x34, 0xaa, 0x7f, 0x0a, 0xd5, 0x6c, 0x47, 0x08, 0x7d, + 0x45, 0x62, 0x10, 0x5f, 0xf7, 0x4c, 0x37, 0x32, 0x79, 0xf7, 0x06, 0xc9, 0xe2, 0x45, 0xd9, 0xad, + 0x76, 0x59, 0x28, 0x51, 0x7e, 0x55, 0x0c, 0x33, 0xa9, 0xde, 0x0f, 0xda, 0x02, 0xe8, 0xa6, 0x29, + 0xcf, 0x96, 0x3c, 0x9c, 0x08, 0xd3, 0x93, 0xd5, 0x9f, 0xa6, 0x8d, 0x31, 0x9c, 0xe4, 0x73, 0x95, + 0x85, 0xca, 0x30, 0xe2, 0xe3, 0x97, 0x3c, 0xae, 0x27, 0x9f, 0xd5, 0xaf, 0x73, 0x50, 0x88, 0x79, + 0x38, 0x3c, 0x33, 0xe5, 0x3a, 0xbe, 0x66, 0xf1, 0x80, 0x3d, 0x6c, 0x93, 0x60, 0x9d, 0xf8, 0x51, + 0x7c, 0x85, 0x64, 0xcf, 0x6b, 0xa4, 0x18, 0x40, 0x8e, 0x48, 0xe2, 0x38, 0x51, 0x42, 0xf4, 0x01, + 0x20, 0xb6, 0x51, 0x9b, 0x96, 0xa3, 0xbf, 0x10, 0xdb, 0x75, 0x84, 0x8a, 0x29, 0xd3, 0x9e, 0x06, + 0xe9, 0xe0, 0xb9, 0x81, 0x77, 0xa1, 0xc8, 0xb0, 0xc3, 0x0d, 0x3a, 0x4a, 0x31, 0x0b, 0x14, 0x2a, + 0x56, 0x72, 0xfc, 0xd4, 0xbd, 0x48, 0x3d, 0xbc, 0x33, 0x9d, 0xba, 0x0d, 0x80, 0xfc, 0x01, 0xc6, + 0x6a, 0xcb, 0x31, 0xb0, 0xac, 0x42, 0x35, 0xcd, 0x27, 0xe4, 0x89, 0xa8, 0x3a, 0x8c, 0x9e, 0x3d, + 0xe7, 0x49, 0x49, 0x65, 0x0d, 0x66, 0xf8, 0x2d, 0xdb, 0x38, 0x61, 0x49, 0x09, 0x9e, 0x36, 0xd9, + 0x80, 0x02, 0xbf, 0xb2, 0xf9, 0x81, 0x3c, 0x44, 0xa6, 0x7e, 0x4a, 0x8b, 0xb4, 0x64, 0x05, 0x66, + 0x93, 0x22, 0xb8, 0xfe, 0x11, 0x7f, 0x48, 0x1a, 0xca, 0x1f, 0x92, 0xa7, 0xa1, 0xf4, 0x4c, 0xb3, + 0x2c, 0xea, 0xa6, 0x30, 0x85, 0xe5, 0x1d, 0x28, 0x77, 0x41, 0x5c, 0xc0, 0x7d, 0x98, 0x38, 0xa6, + 0xb0, 0xee, 0xb2, 0xbd, 0x96, 0x21, 0x22, 0xa4, 0xcd, 0x1f, 0xf3, 0x2f, 0xf9, 0x73, 0x98, 0xa1, + 0xfa, 0x36, 0x4e, 0x84, 0x7c, 0x6e, 0x9b, 0xb3, 0xeb, 0xdd, 0x84, 0xd9, 0x24, 0x4b, 0xae, 0xea, + 0xf9, 0xd9, 0x5b, 0x87, 0xcb, 0x6b, 0xee, 0x11, 0x6e, 0x61, 0x4f, 0xb3, 0x12, 0x8a, 0x9f, 0x9f, + 0x90, 0x3d, 0xa8, 0xf4, 0x0a, 0x79, 0xed, 0x69, 0xfd, 0x47, 0x09, 0x4a, 0x0d, 0xcd, 0x22, 0x5b, + 0xf6, 0xb7, 0x52, 0x33, 0x7a, 0x00, 0x25, 0xea, 0x32, 0xa9, 0xa6, 0x21, 0x98, 0x0d, 0xe8, 0x0b, + 0x17, 0x34, 0xf6, 0xc1, 0xcb, 0x38, 0xbf, 0xc8, 0x41, 0xb9, 0xab, 0x68, 0xb8, 0x1d, 0xc7, 0xb9, + 0xb8, 0x21, 0x54, 0xa4, 0x2e, 0x8e, 0xa0, 0x43, 0xf7, 0x60, 0xbc, 0xc9, 0xd8, 0x72, 0xc5, 0x4e, + 0xf7, 0xf8, 0x18, 0x31, 0xa7, 0x40, 0x8f, 0xa0, 0x24, 0x2c, 0x25, 0xec, 0x3f, 0x72, 0xaa, 0x5f, + 0xc6, 0xf5, 0xd8, 0x37, 0xf1, 0xb1, 0x22, 0x8c, 0xcc, 0x61, 0x68, 0x15, 0xa6, 0x38, 0x5f, 0x95, + 0x44, 0xa7, 0xdc, 0x37, 0xba, 0x71, 0xaa, 0x3a, 0x94, 0xd1, 0x24, 0x27, 0x23, 0x0d, 0xb9, 0x04, + 0x85, 0x5d, 0x9a, 0xa4, 0x15, 0xbb, 0xf4, 0x67, 0x12, 0x14, 0x05, 0x84, 0x9b, 0x6d, 0x1e, 0xca, + 0x07, 0x6d, 0xcb, 0x52, 0xfd, 0x13, 0x5b, 0x8f, 0xe7, 0x68, 0x8b, 0x04, 0xbe, 0x7b, 0x62, 0xeb, + 0xfc, 0x24, 0xae, 0xc1, 0x1b, 0xae, 0xe6, 0x05, 0xa6, 0x16, 0x47, 0x66, 0x17, 0xc9, 0x34, 0xef, + 0x8a, 0xe0, 0x5f, 0x83, 0x49, 0x5d, 0x0b, 0xf4, 0x23, 0xe2, 0x09, 0xb4, 0x5d, 0x5e, 0xf0, 0x03, + 0x01, 0x7a, 0xea, 0xca, 0x33, 0xf0, 0x06, 0x53, 0x66, 0x37, 0xf0, 0xb0, 0xd6, 0x12, 0x4a, 0xfe, + 0x8b, 0x04, 0x97, 0xe2, 0x70, 0xae, 0xea, 0xa7, 0x70, 0x85, 0x97, 0x10, 0x5f, 0xd8, 0xce, 0xb1, + 0x1d, 0xbf, 0x3f, 0x98, 0xce, 0xb3, 0x0c, 0xe1, 0x11, 0xe9, 0x8f, 0xde, 0x22, 0x69, 0xa3, 0xcc, + 0x0d, 0x33, 0xca, 0x91, 0x8c, 0x51, 0xca, 0xff, 0x27, 0xc1, 0xd4, 0xb6, 0x13, 0x74, 0x77, 0xcc, + 0xdb, 0x50, 0x10, 0x95, 0x51, 0xdf, 0x25, 0xf1, 0x11, 0xab, 0x73, 0x4c, 0x71, 0x20, 0x09, 0x60, + 0x03, 0x74, 0x17, 0xf2, 0x62, 0x2b, 0xf0, 0x55, 0xd2, 0x77, 0x0f, 0x8c, 0xf3, 0x3d, 0xd0, 0x7b, + 0x8c, 0x8c, 0x9e, 0xf1, 0x18, 0x41, 0xab, 0x50, 0x62, 0xbe, 0xb7, 0x1a, 0x38, 0x54, 0x59, 0xa3, + 0x32, 0x36, 0x80, 0x13, 0x5e, 0x60, 0x44, 0x7b, 0x0e, 0x0d, 0xc6, 0xe5, 0xbf, 0x94, 0x60, 0x86, + 0x5a, 0x60, 0x9d, 0x7a, 0x0f, 0xa6, 0x7d, 0x28, 0x4c, 0x71, 0x0b, 0xa6, 0x3b, 0x4e, 0xa0, 0x35, + 0x2d, 0xac, 0x6a, 0x41, 0x7c, 0xa2, 0x4a, 0xbc, 0xa3, 0xce, 0x5d, 0xf2, 0xde, 0x51, 0x8d, 0x9c, + 0xf5, 0x70, 0xfc, 0x63, 0x28, 0x3e, 0x33, 0x03, 0x3b, 0x72, 0xf0, 0xa6, 0x55, 0x2a, 0x47, 0xce, + 0xa5, 0x52, 0xa9, 0x42, 0x29, 0x94, 0xc5, 0x57, 0xe9, 0x16, 0x4c, 0x1d, 0x33, 0x10, 0x73, 0x46, + 0x06, 0xaa, 0x9b, 0x71, 0x26, 0xd4, 0x17, 0x99, 0x3c, 0xee, 0x36, 0xe4, 0xff, 0x94, 0x60, 0x96, + 0x77, 0xfe, 0xce, 0xea, 0xaf, 0xe8, 0x0f, 0x01, 0x69, 0xbc, 0xb6, 0xc9, 0x72, 0xe4, 0x91, 0x58, + 0x76, 0xe1, 0x74, 0xde, 0xf5, 0x28, 0x1d, 0x1d, 0xce, 0xb4, 0x96, 0x04, 0xc9, 0xff, 0x95, 0x83, + 0xcb, 0x3d, 0x83, 0xe2, 0xe6, 0xfb, 0xa3, 0x8c, 0xea, 0xee, 0xc7, 0xbd, 0xf9, 0xba, 0x0c, 0x16, + 0xfd, 0x6a, 0xbb, 0x3b, 0x3d, 0xb5, 0xdd, 0xe5, 0xc1, 0x79, 0xff, 0x5e, 0x54, 0x76, 0x7f, 0x31, + 0x02, 0x05, 0x7a, 0x6c, 0x84, 0x3b, 0xa0, 0x0a, 0x79, 0x76, 0xe3, 0x62, 0xe6, 0x89, 0xe5, 0x95, + 0xb0, 0x8d, 0x74, 0x98, 0x8b, 0x1c, 0x58, 0xba, 0x79, 0x60, 0xea, 0xaa, 0x81, 0x6d, 0xa7, 0x65, + 0xda, 0xbc, 0xfe, 0x92, 0xa3, 0xfe, 0x74, 0xe6, 0x65, 0xb8, 0x4a, 0x90, 0x95, 0xab, 0xdd, 0x03, + 0x8e, 0xf2, 0x58, 0x8d, 0xb2, 0x40, 0x77, 0xe1, 0x8a, 0x10, 0x12, 0xa9, 0xbd, 0x04, 0xce, 0x0b, + 0x6c, 0xfb, 0xfc, 0x6a, 0xb8, 0xcc, 0x11, 0x56, 0xc3, 0xfe, 0x3d, 0xda, 0x8d, 0x3e, 0x81, 0x8a, + 0xa0, 0xed, 0xc6, 0xfa, 0x9c, 0x74, 0x94, 0x92, 0xce, 0xf2, 0xfe, 0xa7, 0xa2, 0x9b, 0x53, 0xbe, + 0x07, 0xe2, 0x35, 0x8a, 0x6a, 0xb9, 0xaa, 0x7d, 0x10, 0xf8, 0x34, 0x2d, 0x90, 0x57, 0xc4, 0x11, + 0xbd, 0xe5, 0x6e, 0x1f, 0x04, 0x3e, 0x5a, 0x86, 0x19, 0x81, 0x27, 0xe2, 0x1c, 0x86, 0x3d, 0x46, + 0xb1, 0xdf, 0xe0, 0x9d, 0x3b, 0xbc, 0x8f, 0xd2, 0xd4, 0xe1, 0x2d, 0x41, 0xd3, 0xa1, 0xa7, 0x9e, + 0xea, 0x61, 0x1d, 0x9b, 0x6e, 0x20, 0x54, 0x1b, 0xa7, 0xb4, 0x55, 0x8e, 0x24, 0x4e, 0x46, 0x8a, + 0xc2, 0xd4, 0x93, 0x7f, 0x0c, 0x45, 0x31, 0x4d, 0x7c, 0xf5, 0x3f, 0x80, 0x22, 0x35, 0xbd, 0xda, + 0xc2, 0x81, 0x16, 0xd9, 0x75, 0xd7, 0xb3, 0x6c, 0xff, 0x98, 0xe3, 0x29, 0x05, 0x4a, 0x27, 0x9a, + 0xf2, 0x2c, 0x5c, 0xaa, 0xbb, 0xee, 0x8e, 0xe6, 0x69, 0x2d, 0x1c, 0x60, 0x2f, 0xf4, 0x00, 0x9e, + 0xc3, 0x4c, 0x02, 0xce, 0x25, 0xaf, 0x00, 0xb8, 0x21, 0x34, 0xc3, 0x83, 0xd2, 0x5c, 0x97, 0xee, + 0xf1, 0x18, 0x83, 0x08, 0x99, 0x8c, 0xa0, 0xfc, 0x40, 0xf3, 0x77, 0x3c, 0xb3, 0xeb, 0x41, 0xca, + 0xdf, 0x48, 0x30, 0x1d, 0x01, 0x86, 0x0e, 0x37, 0x1c, 0x6a, 0xbe, 0xea, 0x52, 0x68, 0xc6, 0xc2, + 0xef, 0xc9, 0x6b, 0x76, 0xd9, 0x4c, 0x1c, 0x8a, 0x4f, 0xf4, 0x04, 0x8a, 0x9a, 0x15, 0xa8, 0x11, + 0x6e, 0x6c, 0xb9, 0x0e, 0xc1, 0x6d, 0x4a, 0xb3, 0x82, 0xb0, 0x45, 0x4c, 0xb7, 0xfe, 0x78, 0xb5, + 0xd7, 0x74, 0x2e, 0xcc, 0x24, 0xe0, 0x7c, 0x2c, 0xcf, 0x52, 0x4c, 0xf7, 0x71, 0x76, 0xf0, 0x19, + 0x7b, 0x95, 0xd6, 0x59, 0xaa, 0xad, 0xb7, 0x8c, 0x0c, 0x73, 0xfe, 0x8d, 0x04, 0x97, 0xc9, 0xcd, + 0xda, 0x38, 0x89, 0xe4, 0x4f, 0xf9, 0x8e, 0xde, 0x81, 0x12, 0x7d, 0xfe, 0x13, 0x49, 0xc4, 0xe6, + 0x86, 0x4c, 0xc4, 0x12, 0xfa, 0x6e, 0x3b, 0xed, 0x89, 0xc6, 0x48, 0xea, 0x13, 0x8d, 0x23, 0xa8, + 0xf4, 0x6a, 0x15, 0xde, 0x7e, 0x45, 0x5f, 0x3c, 0x38, 0x52, 0x89, 0x80, 0x8a, 0x34, 0xcc, 0xc3, + 0xa4, 0x82, 0x1f, 0x05, 0x52, 0x03, 0xec, 0x1e, 0x6b, 0x6e, 0x86, 0x01, 0x92, 0x99, 0xe8, 0xdc, + 0x6b, 0x65, 0xa2, 0x07, 0x37, 0xc0, 0x16, 0x54, 0x7a, 0xb5, 0xe2, 0x06, 0x58, 0x84, 0x51, 0xc2, + 0xb6, 0x37, 0x7f, 0x1d, 0x0e, 0xfb, 0x58, 0x73, 0xf9, 0x68, 0x29, 0xa6, 0x7c, 0x19, 0x66, 0x9e, + 0xda, 0x34, 0xe3, 0x8e, 0x0d, 0xd2, 0x19, 0x2e, 0xb8, 0x87, 0x30, 0x9b, 0xec, 0x38, 0xb3, 0x90, + 0xaf, 0x25, 0x98, 0xdd, 0x6e, 0x5b, 0x96, 0x79, 0x60, 0x62, 0x2f, 0x16, 0x14, 0xa0, 0x07, 0x30, + 0x61, 0x8b, 0x1e, 0x6e, 0xc2, 0x9b, 0xfd, 0xea, 0x41, 0x21, 0x2b, 0xa5, 0x4b, 0x3b, 0xb8, 0xfd, + 0x16, 0xe0, 0x72, 0x8f, 0x2e, 0x7c, 0x64, 0x97, 0xe0, 0x22, 0xf3, 0x9a, 0xd9, 0x2d, 0xc5, 0x1a, + 0xf2, 0x3e, 0x5c, 0x8d, 0xbe, 0x56, 0xb1, 0x0f, 0x9c, 0xc6, 0xc9, 0x86, 0xe6, 0x1f, 0x89, 0x21, + 0xb0, 0x07, 0x2f, 0xb9, 0x61, 0x1f, 0xbc, 0xc8, 0x5f, 0xc2, 0x6c, 0x82, 0xaf, 0xe0, 0x78, 0x03, + 0xa6, 0x62, 0xd9, 0x64, 0xe6, 0xb5, 0x4e, 0xfa, 0xdd, 0x24, 0x32, 0x7a, 0x0b, 0x00, 0xdb, 0x46, + 0x3c, 0x9a, 0x98, 0xc0, 0xb6, 0xc1, 0x03, 0x83, 0x5f, 0xe5, 0xa0, 0x94, 0x60, 0x8e, 0x66, 0x61, + 0x2c, 0xc6, 0x8f, 0xb7, 0xce, 0xaa, 0x7f, 0xd2, 0x7f, 0x18, 0x79, 0xad, 0x27, 0x5a, 0xfb, 0x30, + 0xe9, 0x62, 0x8f, 0xb8, 0x00, 0xf4, 0x35, 0xe7, 0x68, 0xf2, 0xd9, 0x5b, 0x3f, 0x57, 0xb2, 0x4b, + 0xab, 0x44, 0x19, 0xa1, 0x3a, 0x8c, 0xd2, 0x18, 0xf6, 0xe2, 0x90, 0xbe, 0x29, 0x8d, 0x67, 0x29, + 0xa9, 0xfc, 0x14, 0x2e, 0xf7, 0xcc, 0x13, 0x5f, 0x30, 0x77, 0x61, 0x3c, 0x78, 0xa5, 0x9a, 0xf6, + 0x81, 0xc3, 0x77, 0xc3, 0x8d, 0x53, 0x0b, 0xbb, 0x94, 0x76, 0x2c, 0x78, 0x45, 0xfe, 0xca, 0x3f, + 0x81, 0xb7, 0x32, 0x96, 0xd5, 0x39, 0x30, 0x7f, 0x06, 0x05, 0x1e, 0x17, 0x72, 0x66, 0x89, 0x07, + 0x9b, 0xd2, 0x19, 0x1f, 0x6c, 0xca, 0xff, 0x44, 0xb6, 0x72, 0x22, 0xde, 0x3a, 0x5f, 0x11, 0x68, + 0x0d, 0xa6, 0x44, 0x71, 0x49, 0x7d, 0x81, 0x4f, 0xf8, 0xca, 0x1c, 0xa4, 0xc0, 0x34, 0x69, 0x76, + 0x1b, 0xf2, 0xbf, 0x8e, 0xc2, 0x1b, 0x29, 0xa2, 0xd2, 0xee, 0x2e, 0xe9, 0xf5, 0xee, 0xae, 0x06, + 0x8c, 0xda, 0xdd, 0xa4, 0x74, 0x6d, 0xf0, 0xcb, 0x97, 0x6a, 0x45, 0x69, 0xcf, 0x2f, 0x02, 0x8d, + 0x9f, 0xa8, 0xa3, 0xaf, 0x71, 0xa2, 0xbe, 0x0b, 0x45, 0x76, 0x42, 0xa8, 0xba, 0x87, 0xb5, 0x00, + 0x1b, 0xbc, 0xaa, 0x55, 0x60, 0xd0, 0x15, 0x06, 0x24, 0x87, 0x15, 0x47, 0x63, 0x67, 0xe7, 0x18, + 0x3b, 0xac, 0x18, 0x8c, 0x25, 0x1c, 0xaa, 0x91, 0x0a, 0xd7, 0x38, 0xcf, 0xe8, 0x8b, 0xdc, 0xf9, + 0x46, 0xf8, 0x7a, 0x2e, 0x4f, 0x75, 0x5d, 0xec, 0xa7, 0x6b, 0xd7, 0xf0, 0xbb, 0x94, 0x2e, 0x7c, + 0x4a, 0xb7, 0x09, 0x45, 0x0f, 0x07, 0x6d, 0xcf, 0x0e, 0x53, 0x60, 0x13, 0x03, 0xa7, 0xc0, 0x0a, + 0x8c, 0x92, 0x83, 0xe4, 0xff, 0x18, 0x01, 0xe8, 0xde, 0x62, 0xe7, 0x5f, 0x77, 0x26, 0xc7, 0x12, + 0xbd, 0x43, 0x73, 0x7d, 0xea, 0x29, 0xbc, 0x3e, 0x45, 0x74, 0x89, 0x3c, 0x3b, 0x24, 0xa4, 0x31, + 0xa3, 0x8e, 0x24, 0x8c, 0x7a, 0x6e, 0x6b, 0x60, 0x0f, 0x26, 0xd9, 0xdb, 0x42, 0x51, 0xdb, 0x20, + 0xac, 0xee, 0xf4, 0x53, 0xb7, 0xa1, 0x05, 0xfa, 0x11, 0xd1, 0x99, 0xbd, 0xd4, 0xa0, 0x91, 0x38, + 0x38, 0xe1, 0x77, 0x74, 0x65, 0x31, 0x07, 0x83, 0x2f, 0x1a, 0xb1, 0xb2, 0x18, 0x30, 0xb2, 0x34, + 0xc6, 0x5f, 0x6f, 0x69, 0xc8, 0xff, 0x26, 0xc1, 0xe5, 0x27, 0xc7, 0x36, 0x36, 0xba, 0xc5, 0xc7, + 0xd0, 0x03, 0xd9, 0x8b, 0x3c, 0x38, 0x63, 0xbf, 0x0e, 0x90, 0x06, 0x9b, 0x14, 0xc1, 0x8b, 0xce, + 0x75, 0xf7, 0x95, 0x19, 0xfb, 0x25, 0x41, 0xb2, 0x10, 0x99, 0x7b, 0xbd, 0x42, 0xa4, 0x7c, 0x08, + 0x95, 0xde, 0x01, 0xf0, 0x83, 0xf7, 0x3c, 0xeb, 0xb0, 0xf2, 0x3e, 0x54, 0x68, 0x58, 0x28, 0x82, + 0xb9, 0xc6, 0x49, 0x58, 0x67, 0x89, 0x25, 0x0e, 0x73, 0xc3, 0x25, 0x0e, 0x65, 0x03, 0xae, 0xa4, + 0xf0, 0xcd, 0x8c, 0x3c, 0xa5, 0xb3, 0x45, 0x9e, 0x7f, 0x97, 0x83, 0xeb, 0xdd, 0x10, 0xde, 0x0f, + 0x6b, 0x2d, 0xbf, 0x9d, 0xfa, 0x16, 0xfa, 0x1c, 0xc6, 0x22, 0xb5, 0x84, 0x62, 0xda, 0xbb, 0xae, + 0x7e, 0xda, 0xd4, 0x58, 0x59, 0x41, 0xe1, 0x8c, 0xe4, 0xaf, 0x60, 0x8c, 0x57, 0x2c, 0x66, 0x01, + 0xad, 0x6f, 0x6e, 0xed, 0xad, 0x29, 0xea, 0xd3, 0xed, 0xdd, 0x9d, 0xb5, 0x95, 0xcd, 0xf5, 0xcd, + 0xb5, 0xd5, 0xf2, 0x05, 0x74, 0x1b, 0xde, 0xe7, 0xf0, 0xfa, 0xd6, 0x96, 0x5a, 0x5f, 0xd9, 0xdb, + 0xdc, 0x5f, 0x53, 0x9f, 0x6d, 0xee, 0x6d, 0xa8, 0xdb, 0x4f, 0xb6, 0xbf, 0x5c, 0x53, 0x9e, 0xa8, + 0x8d, 0xfa, 0x56, 0x7d, 0x7b, 0x65, 0x6d, 0xb7, 0x2c, 0xa1, 0x22, 0x40, 0x17, 0xb9, 0x9c, 0x93, + 0x31, 0xdc, 0x38, 0x45, 0x23, 0x3e, 0x1d, 0x7f, 0x00, 0x40, 0x9f, 0x93, 0xb0, 0xf4, 0xbf, 0x34, + 0x68, 0xfa, 0x7f, 0xa2, 0x23, 0x3e, 0xe5, 0xbf, 0xcd, 0xc1, 0x3b, 0x89, 0x7c, 0x48, 0xfa, 0x5c, + 0x3c, 0x0d, 0x2d, 0x28, 0x51, 0x0b, 0x7e, 0xd6, 0x6b, 0xc1, 0x41, 0xf8, 0x24, 0xac, 0xd8, 0x3b, + 0xc5, 0xb9, 0xb3, 0x57, 0xbb, 0xfa, 0xcd, 0xc7, 0x25, 0x28, 0x73, 0xf8, 0xca, 0x56, 0x7d, 0xf3, + 0x71, 0xbd, 0xb1, 0xb5, 0x56, 0x96, 0xd0, 0x55, 0xa8, 0x70, 0xe8, 0xf6, 0x93, 0x3d, 0xf5, 0xc7, + 0x6b, 0x7b, 0x91, 0xde, 0x9c, 0xfc, 0xe7, 0x12, 0xbc, 0xdb, 0x67, 0x5c, 0xe7, 0x35, 0x17, 0xe8, + 0x2a, 0x4c, 0xd0, 0x63, 0x96, 0xf8, 0x41, 0xbc, 0x1e, 0xd0, 0x05, 0x2c, 0xff, 0xfd, 0x65, 0x98, + 0x24, 0x68, 0xbb, 0xd8, 0xeb, 0x98, 0xb4, 0x92, 0x34, 0xc6, 0xa2, 0x22, 0x74, 0x2d, 0xc5, 0x75, + 0x8b, 0xc6, 0x6e, 0xd5, 0xeb, 0xd9, 0x08, 0x5c, 0x79, 0x15, 0xa6, 0xa2, 0xc5, 0x14, 0xf4, 0x6e, + 0x16, 0x45, 0xac, 0x08, 0x53, 0x7d, 0xaf, 0x1f, 0x1a, 0x63, 0xbf, 0x28, 0xa1, 0x87, 0x70, 0x91, + 0x7a, 0xa3, 0x68, 0xae, 0x97, 0x24, 0x5a, 0x18, 0xa9, 0x5e, 0xcb, 0xec, 0x0f, 0x79, 0x61, 0x28, + 0xc6, 0x3d, 0x5b, 0xf4, 0x7e, 0x06, 0x51, 0xb2, 0xd6, 0x50, 0x9d, 0xef, 0x8f, 0x18, 0x8a, 0x79, + 0x0c, 0x63, 0x2c, 0xef, 0x96, 0x66, 0xe0, 0x58, 0xe2, 0x34, 0xcd, 0xc0, 0xf1, 0x94, 0xdd, 0xa2, + 0x84, 0x2c, 0x98, 0xee, 0x39, 0x57, 0xd1, 0xad, 0x0c, 0xc2, 0x94, 0x43, 0xbd, 0x7a, 0x7b, 0x20, + 0xdc, 0x30, 0x41, 0x5e, 0x88, 0x25, 0xe0, 0x50, 0xca, 0x54, 0xa5, 0xa5, 0xfe, 0xaa, 0xef, 0xf7, + 0xc5, 0xe3, 0x12, 0xf6, 0x60, 0x22, 0xcc, 0x86, 0x21, 0xb9, 0x97, 0x2a, 0x99, 0xe2, 0xab, 0xbe, + 0x7d, 0x2a, 0x4e, 0x57, 0xef, 0x58, 0xfa, 0x2c, 0x4d, 0xef, 0xb4, 0xbc, 0x5b, 0x9a, 0xde, 0xe9, + 0x79, 0x38, 0x1d, 0x8a, 0xf1, 0xa7, 0x0e, 0x69, 0xab, 0x27, 0xf5, 0xbd, 0x45, 0xda, 0xea, 0xc9, + 0x78, 0x35, 0xf1, 0x39, 0xe4, 0xc5, 0x63, 0x05, 0x94, 0x12, 0x0d, 0x26, 0xde, 0x45, 0x54, 0xe5, + 0xd3, 0x50, 0xba, 0x7a, 0xc7, 0x9f, 0x25, 0xa4, 0xe9, 0x9d, 0xfa, 0x16, 0x22, 0x4d, 0xef, 0x8c, + 0x17, 0x0e, 0x26, 0x94, 0x93, 0x4f, 0x06, 0xd0, 0xcd, 0x5e, 0xea, 0x8c, 0xb7, 0x0b, 0xd5, 0x5b, + 0x83, 0xa0, 0x72, 0x51, 0xbb, 0x90, 0x17, 0xd5, 0xf9, 0x34, 0x13, 0x25, 0x9e, 0x18, 0xa4, 0x99, + 0x28, 0x59, 0xdc, 0x5f, 0x94, 0x88, 0xfe, 0xc9, 0xa4, 0x63, 0x9a, 0xfe, 0x19, 0xe9, 0xd2, 0x34, + 0xfd, 0x33, 0x73, 0x98, 0x26, 0x94, 0x93, 0xe9, 0xbd, 0x34, 0x51, 0x19, 0x89, 0xc9, 0x34, 0x51, + 0x99, 0xd9, 0x42, 0x0c, 0xc5, 0x78, 0x8a, 0x2f, 0x6d, 0xea, 0x53, 0xb3, 0x83, 0x69, 0x53, 0x9f, + 0x9e, 0x2d, 0x5c, 0x94, 0xd0, 0x01, 0x94, 0x12, 0x09, 0x37, 0x94, 0x76, 0x5e, 0xa6, 0xe6, 0x07, + 0xab, 0x37, 0x07, 0xc0, 0xe4, 0xc3, 0x79, 0x05, 0x33, 0xa9, 0x09, 0x15, 0x54, 0xeb, 0x9b, 0x37, + 0x89, 0x25, 0xf4, 0xaa, 0x0b, 0x03, 0xe3, 0x73, 0xc9, 0x47, 0xbd, 0xc9, 0xb6, 0xf9, 0xfe, 0xb9, + 0x9a, 0xec, 0x11, 0x66, 0xa4, 0x9b, 0x16, 0x25, 0xf4, 0x02, 0xca, 0xc9, 0x30, 0x20, 0x6d, 0x75, + 0x64, 0xc4, 0x3a, 0x69, 0xab, 0x23, 0x2b, 0xaa, 0x58, 0x94, 0x90, 0x03, 0xa8, 0xf7, 0x05, 0x1a, + 0xba, 0x3d, 0xc4, 0x6f, 0x17, 0xaa, 0x1f, 0x0c, 0x86, 0xcc, 0xed, 0xb8, 0x0d, 0xe3, 0xbc, 0xf4, + 0x89, 0xae, 0x67, 0x56, 0x45, 0x05, 0xeb, 0x1b, 0xa7, 0x60, 0x74, 0xe7, 0x25, 0x51, 0x4a, 0x4d, + 0x9b, 0x97, 0xf4, 0x0a, 0x77, 0xda, 0xbc, 0x64, 0xd4, 0x65, 0x17, 0x25, 0x64, 0xc3, 0x74, 0xcf, + 0x0f, 0x72, 0x53, 0x6f, 0xe1, 0x8c, 0xdf, 0x33, 0xa7, 0xde, 0xc2, 0x59, 0xbf, 0xf0, 0x5d, 0x94, + 0xd0, 0x31, 0x5c, 0x4a, 0xfb, 0xd1, 0x27, 0xfa, 0xc1, 0xa0, 0x3f, 0x0e, 0x65, 0x52, 0x6b, 0xc3, + 0xfd, 0x96, 0x74, 0x51, 0x42, 0x7f, 0x26, 0xc1, 0x95, 0xcc, 0x00, 0x02, 0x2d, 0x0f, 0x1f, 0xff, + 0x54, 0xef, 0x0c, 0x45, 0x13, 0x2a, 0xf2, 0xd7, 0x12, 0xbc, 0x75, 0xaa, 0x07, 0x8d, 0x3e, 0x3a, + 0x5b, 0x28, 0x51, 0xfd, 0x78, 0x68, 0xba, 0x50, 0xa9, 0x5d, 0xc8, 0x8b, 0x5f, 0xf8, 0xa7, 0x5d, + 0x3e, 0x89, 0xff, 0x89, 0x90, 0x76, 0xf9, 0x24, 0xff, 0x41, 0xc0, 0xa2, 0xd4, 0xf8, 0x8d, 0xf4, + 0xcb, 0xef, 0xe6, 0xa4, 0x5f, 0x7f, 0x37, 0x27, 0xfd, 0xe6, 0xbb, 0x39, 0xe9, 0xaf, 0xbe, 0x9f, + 0xbb, 0xf0, 0xeb, 0xef, 0xe7, 0x2e, 0x7c, 0xfb, 0xfd, 0xdc, 0x05, 0xb8, 0xa4, 0x3b, 0xad, 0x1e, + 0x1e, 0x8d, 0x09, 0xe2, 0xcf, 0xef, 0x78, 0x4e, 0xe0, 0xec, 0x48, 0x5f, 0xae, 0x1c, 0x9a, 0xc1, + 0x51, 0xbb, 0x49, 0xe2, 0xff, 0x05, 0xdd, 0xf1, 0x5b, 0x8e, 0xbf, 0x40, 0x7f, 0x0f, 0x88, 0xbd, + 0x85, 0xce, 0x72, 0xf8, 0xa9, 0x1f, 0x69, 0xa6, 0xed, 0x2f, 0x24, 0xff, 0xfb, 0xc8, 0x3d, 0xf2, + 0xb7, 0xb3, 0xf4, 0x0f, 0xb9, 0x91, 0x9d, 0xfd, 0x2f, 0xfe, 0x39, 0x57, 0xde, 0x11, 0xa2, 0x88, + 0x84, 0xda, 0xfe, 0xd2, 0xbf, 0x77, 0x41, 0xcf, 0x09, 0xe8, 0xf9, 0xfe, 0xd2, 0x77, 0xb9, 0xab, + 0x49, 0xd0, 0xf3, 0x07, 0x3b, 0x0d, 0xe1, 0x4d, 0xfe, 0x77, 0x0e, 0x89, 0xee, 0xbb, 0x77, 0x49, + 0xff, 0xdd, 0xbb, 0xfb, 0x4b, 0xcd, 0x31, 0xfa, 0xdf, 0x0a, 0xee, 0xfc, 0x7f, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xb7, 0x2e, 0xd7, 0x00, 0xff, 0x44, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -7132,6 +7298,22 @@ func (m *TransactionPlannerRequest) MarshalToSizedBuffer(dAtA []byte) (int, erro } } } + if len(m.DelegatorVotes) > 0 { + for iNdEx := len(m.DelegatorVotes) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.DelegatorVotes[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintView(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x4 + i-- + dAtA[i] = 0xe2 + } + } if len(m.DutchAuctionWithdrawActions) > 0 { for iNdEx := len(m.DutchAuctionWithdrawActions) - 1; iNdEx >= 0; iNdEx-- { { @@ -7340,6 +7522,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 +7679,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) @@ -7989,6 +8234,70 @@ func (m *TransactionPlannerRequest_ActionDutchAuctionWithdraw) MarshalToSizedBuf return len(dAtA) - i, nil } +func (m *TransactionPlannerRequest_DelegatorVote) 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_DelegatorVote) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *TransactionPlannerRequest_DelegatorVote) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.RateData) > 0 { + for iNdEx := len(m.RateData) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.RateData[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintView(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + } + if m.StartPosition != 0 { + i = encodeVarintView(dAtA, i, uint64(m.StartPosition)) + i-- + dAtA[i] = 0x20 + } + if m.StartBlockHeight != 0 { + i = encodeVarintView(dAtA, i, uint64(m.StartBlockHeight)) + i-- + dAtA[i] = 0x18 + } + if m.Vote != nil { + { + size, err := m.Vote.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintView(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Proposal != 0 { + i = encodeVarintView(dAtA, i, uint64(m.Proposal)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + func (m *TransactionPlannerResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -10572,6 +10881,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() @@ -10650,6 +10965,12 @@ func (m *TransactionPlannerRequest) Size() (n int) { n += 2 + l + sovView(uint64(l)) } } + if len(m.DelegatorVotes) > 0 { + for _, e := range m.DelegatorVotes { + l = e.Size() + n += 2 + l + sovView(uint64(l)) + } + } if m.FeeMode != nil { n += m.FeeMode.Size() } @@ -10704,7 +11025,7 @@ func (m *TransactionPlannerRequest_Output) Size() (n int) { return n } -func (m *TransactionPlannerRequest_Swap) Size() (n int) { +func (m *TransactionPlannerRequest_Spend) Size() (n int) { if m == nil { return 0 } @@ -10714,22 +11035,39 @@ func (m *TransactionPlannerRequest_Swap) Size() (n int) { l = m.Value.Size() n += 1 + l + sovView(uint64(l)) } - if m.TargetAsset != nil { - l = m.TargetAsset.Size() - n += 1 + l + sovView(uint64(l)) - } - if m.Fee != nil { - l = m.Fee.Size() - n += 1 + l + sovView(uint64(l)) - } - if m.ClaimAddress != nil { - l = m.ClaimAddress.Size() + if m.Address != nil { + l = m.Address.Size() n += 1 + l + sovView(uint64(l)) } return n } -func (m *TransactionPlannerRequest_SwapClaim) Size() (n int) { +func (m *TransactionPlannerRequest_Swap) 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.TargetAsset != nil { + l = m.TargetAsset.Size() + n += 1 + l + sovView(uint64(l)) + } + if m.Fee != nil { + l = m.Fee.Size() + n += 1 + l + sovView(uint64(l)) + } + if m.ClaimAddress != nil { + l = m.ClaimAddress.Size() + n += 1 + l + sovView(uint64(l)) + } + return n +} + +func (m *TransactionPlannerRequest_SwapClaim) Size() (n int) { if m == nil { return 0 } @@ -10892,6 +11230,34 @@ func (m *TransactionPlannerRequest_ActionDutchAuctionWithdraw) Size() (n int) { return n } +func (m *TransactionPlannerRequest_DelegatorVote) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Proposal != 0 { + n += 1 + sovView(uint64(m.Proposal)) + } + if m.Vote != nil { + l = m.Vote.Size() + n += 1 + l + sovView(uint64(l)) + } + if m.StartBlockHeight != 0 { + n += 1 + sovView(uint64(m.StartBlockHeight)) + } + if m.StartPosition != 0 { + n += 1 + sovView(uint64(m.StartPosition)) + } + if len(m.RateData) > 0 { + for _, e := range m.RateData { + l = e.Size() + n += 1 + l + sovView(uint64(l)) + } + } + return n +} + func (m *TransactionPlannerResponse) Size() (n int) { if m == nil { return 0 @@ -13078,6 +13444,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) @@ -13520,6 +13920,40 @@ func (m *TransactionPlannerRequest) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 76: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DelegatorVotes", 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.DelegatorVotes = append(m.DelegatorVotes, &TransactionPlannerRequest_DelegatorVote{}) + if err := m.DelegatorVotes[len(m.DelegatorVotes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex case 100: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field AutoFee", wireType) @@ -13788,6 +14222,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 @@ -15115,6 +15671,183 @@ func (m *TransactionPlannerRequest_ActionDutchAuctionWithdraw) Unmarshal(dAtA [] } return nil } +func (m *TransactionPlannerRequest_DelegatorVote) 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: DelegatorVote: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DelegatorVote: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Proposal", wireType) + } + m.Proposal = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowView + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Proposal |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Vote", 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.Vote == nil { + m.Vote = &v112.Vote{} + } + if err := m.Vote.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StartBlockHeight", wireType) + } + m.StartBlockHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowView + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StartBlockHeight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StartPosition", wireType) + } + m.StartPosition = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowView + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.StartPosition |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RateData", 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.RateData = append(m.RateData, &v111.RateData{}) + if err := m.RateData[len(m.RateData)-1].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 *TransactionPlannerResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -17727,7 +18460,7 @@ func (m *AppParametersResponse) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Parameters == nil { - m.Parameters = &v112.AppParameters{} + m.Parameters = &v113.AppParameters{} } if err := m.Parameters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -18033,7 +18766,7 @@ func (m *FMDParametersResponse) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Parameters == nil { - m.Parameters = &v113.FmdParameters{} + m.Parameters = &v114.FmdParameters{} } if err := m.Parameters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -19618,7 +20351,7 @@ func (m *SpendableNoteRecord) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Note == nil { - m.Note = &v113.Note{} + m.Note = &v114.Note{} } if err := m.Note.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err From 4e3755ecf8b3aeea5c47712970c551f1815c5345 Mon Sep 17 00:00:00 2001 From: hatti Date: Mon, 8 Jul 2024 03:15:06 +0800 Subject: [PATCH 2/4] fix comment (#1476) Co-authored-by: Justin Tieri <37750742+jtieri@users.noreply.github.com> --- cmd/tx.go | 2 +- relayer/chains/penumbra/tx.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/cmd/tx.go b/cmd/tx.go index 47f37a41d..252fd5233 100644 --- a/cmd/tx.go +++ b/cmd/tx.go @@ -1214,7 +1214,7 @@ func ensureKeysExist(chains map[string]*relayer.Chain) error { return nil } -// MsgRegisterCounterpartyPayee registers the counterparty_payee +// registerCounterpartyCmd registers the counterparty_payee func registerCounterpartyCmd(a *appState) *cobra.Command { cmd := &cobra.Command{ Use: "register-counterparty chain_name channel_id port_id relay_addr counterparty_payee", diff --git a/relayer/chains/penumbra/tx.go b/relayer/chains/penumbra/tx.go index 778e04f04..8262891be 100644 --- a/relayer/chains/penumbra/tx.go +++ b/relayer/chains/penumbra/tx.go @@ -437,7 +437,7 @@ func parseEventsFromTxResponse(resp *sdk.TxResponse) []provider.RelayerEvent { return events } -// CreateClient creates an sdk.Msg to update the client on src with consensus state from dst +// MsgCreateClient creates an sdk.Msg to update the client on src with consensus state from dst func (cc *PenumbraProvider) MsgCreateClient(clientState ibcexported.ClientState, consensusState ibcexported.ConsensusState) (provider.RelayerMessage, error) { signer, err := cc.Address() if err != nil { From 6ab7f6198f341b10f7514041c0122233d8d952c5 Mon Sep 17 00:00:00 2001 From: cui <523516579@qq.com> Date: Mon, 8 Jul 2024 03:55:05 +0800 Subject: [PATCH 3/4] reactor: simplify error (#1480) Co-authored-by: Justin Tieri <37750742+jtieri@users.noreply.github.com> --- relayer/chains/cosmos/account.go | 6 ++---- relayer/chains/cosmos/keys.go | 5 +---- 2 files changed, 3 insertions(+), 8 deletions(-) diff --git a/relayer/chains/cosmos/account.go b/relayer/chains/cosmos/account.go index 311939589..34ae744d6 100644 --- a/relayer/chains/cosmos/account.go +++ b/relayer/chains/cosmos/account.go @@ -58,10 +58,8 @@ func (cc *CosmosProvider) GetAccountWithHeight(_ client.Context, addr sdk.AccAdd // EnsureExists returns an error if no account exists for the given address else nil. func (cc *CosmosProvider) EnsureExists(clientCtx client.Context, addr sdk.AccAddress) error { - if _, err := cc.GetAccount(clientCtx, addr); err != nil { - return err - } - return nil + _, err := cc.GetAccount(clientCtx, addr) + return err } // GetAccountNumberSequence returns sequence and account number for the given address. diff --git a/relayer/chains/cosmos/keys.go b/relayer/chains/cosmos/keys.go index 3f2650b19..f45a90769 100644 --- a/relayer/chains/cosmos/keys.go +++ b/relayer/chains/cosmos/keys.go @@ -180,10 +180,7 @@ func (cc *CosmosProvider) ListAddresses() (map[string]string, error) { // DeleteKey removes a key from the keystore for the specified name. func (cc *CosmosProvider) DeleteKey(name string) error { - if err := cc.Keybase.Delete(name); err != nil { - return err - } - return nil + return cc.Keybase.Delete(name) } // KeyExists returns true if a key with the specified name exists in the keystore, it returns false otherwise. From a2258edd495cf92a92805aae1a6c3b4e27603e1a Mon Sep 17 00:00:00 2001 From: cui <523516579@qq.com> Date: Tue, 16 Jul 2024 20:35:08 +0800 Subject: [PATCH 4/4] refactor: return err directly (#1481) --- relayer/chains/cosmos/tx.go | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/relayer/chains/cosmos/tx.go b/relayer/chains/cosmos/tx.go index eb8d03023..03cf830f3 100644 --- a/relayer/chains/cosmos/tx.go +++ b/relayer/chains/cosmos/tx.go @@ -1676,10 +1676,7 @@ func (cc *CosmosProvider) PrepareFactory(txf tx.Factory, signingKey string) (tx. // Set the account number and sequence on the transaction factory and retry if fail if err = retry.Do(func() error { - if err = txf.AccountRetriever().EnsureExists(cliCtx, from); err != nil { - return err - } - return err + return txf.AccountRetriever().EnsureExists(cliCtx, from) }, rtyAtt, rtyDel, rtyErr); err != nil { return txf, err }