From 8060c4f496ac64a822b2a7f0e5c7daaa3f634be7 Mon Sep 17 00:00:00 2001 From: Simon Noetzlin Date: Fri, 23 Feb 2024 15:15:37 +0100 Subject: [PATCH] feat! use protos to serialize opted-in validators (#1659) move OptedInValidators to proto Co-authored-by: insumity --- .../ccv/provider/v1/provider.proto | 13 + x/ccv/provider/keeper/distribution_test.go | 9 +- x/ccv/provider/keeper/keeper.go | 38 +- x/ccv/provider/keeper/keeper_test.go | 56 +- x/ccv/provider/keeper/key_assignment.go | 4 +- x/ccv/provider/keeper/partial_set_security.go | 6 - .../keeper/partial_set_security_test.go | 7 +- x/ccv/provider/types/keys.go | 4 +- x/ccv/provider/types/provider.pb.go | 526 ++++++++++++++---- 9 files changed, 499 insertions(+), 164 deletions(-) diff --git a/proto/interchain_security/ccv/provider/v1/provider.proto b/proto/interchain_security/ccv/provider/v1/provider.proto index b4a512e36d..39e71df522 100644 --- a/proto/interchain_security/ccv/provider/v1/provider.proto +++ b/proto/interchain_security/ccv/provider/v1/provider.proto @@ -313,3 +313,16 @@ message ConsumerRewardsAllocation { (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.DecCoins" ]; } + +// OptedInValidator is used to store a opted-in validator +// to a consumer chain with the following mapping: (chainID, providerAddr) -> optedInValidator +message OptedInValidator { + // validator address + bytes provider_addr = 1; + // block height at which the validator opted-in + int64 block_height = 2; + // validator voting power at the block it opted-in + int64 power = 3; + // public key used by the validator on the consumer + bytes public_key = 4; +} diff --git a/x/ccv/provider/keeper/distribution_test.go b/x/ccv/provider/keeper/distribution_test.go index b8883177b1..52ac0e0a82 100644 --- a/x/ccv/provider/keeper/distribution_test.go +++ b/x/ccv/provider/keeper/distribution_test.go @@ -38,8 +38,12 @@ func TestComputeConsumerTotalVotingPower(t *testing.T) { keeper.SetOptedIn( ctx, chainID, - types.NewProviderConsAddress(sdk.ConsAddress(val.Address)), - 0, + types.OptedInValidator{ + ProviderAddr: val.Address, + BlockHeight: ctx.BlockHeight(), + Power: val.VotingPower, + PublicKey: val.PubKey.Bytes(), + }, ) validatorsVotes = append( @@ -65,7 +69,6 @@ func TestComputeConsumerTotalVotingPower(t *testing.T) { } func TestIdentifyConsumerChainIDFromIBCPacket(t *testing.T) { - var ( chainID = "consumer" ccvChannel = "channel-0" diff --git a/x/ccv/provider/keeper/keeper.go b/x/ccv/provider/keeper/keeper.go index 42bcb12ace..e6b1c589aa 100644 --- a/x/ccv/provider/keeper/keeper.go +++ b/x/ccv/provider/keeper/keeper.go @@ -1189,16 +1189,15 @@ func (k Keeper) IsOptIn(ctx sdk.Context, chainID string) bool { func (k Keeper) SetOptedIn( ctx sdk.Context, chainID string, - providerAddr types.ProviderConsAddress, - blockHeight uint64, + validator types.OptedInValidator, ) { store := ctx.KVStore(k.storeKey) + bz, err := validator.Marshal() + if err != nil { + panic(fmt.Errorf("failed to marshal OptedInValidator: %w", err)) + } - // validator is considered opted in - blockHeightBytes := make([]byte, 8) - binary.BigEndian.PutUint64(blockHeightBytes, blockHeight) - - store.Set(types.OptedInKey(chainID, providerAddr), blockHeightBytes) + store.Set(types.OptedInKey(chainID, validator.ProviderAddr), bz) } func (k Keeper) DeleteOptedIn( @@ -1207,7 +1206,7 @@ func (k Keeper) DeleteOptedIn( providerAddr types.ProviderConsAddress, ) { store := ctx.KVStore(k.storeKey) - store.Delete(types.OptedInKey(chainID, providerAddr)) + store.Delete(types.OptedInKey(chainID, providerAddr.ToSdkConsAddr())) } func (k Keeper) IsOptedIn( @@ -1216,22 +1215,25 @@ func (k Keeper) IsOptedIn( providerAddr types.ProviderConsAddress, ) bool { store := ctx.KVStore(k.storeKey) - return store.Get(types.OptedInKey(chainID, providerAddr)) != nil + return store.Get(types.OptedInKey(chainID, providerAddr.ToSdkConsAddr())) != nil } -func (k Keeper) GetOptedIn( +// GetAllOptedIn returns all the opted-in validators on chain `chainID` +func (k Keeper) GetAllOptedIn( ctx sdk.Context, - chainID string) (optedInValidators []OptedInValidator) { + chainID string) (optedInValidators []types.OptedInValidator) { store := ctx.KVStore(k.storeKey) key := types.ChainIdWithLenKey(types.OptedInBytePrefix, chainID) iterator := sdk.KVStorePrefixIterator(store, key) defer iterator.Close() for ; iterator.Valid(); iterator.Next() { - optedInValidators = append(optedInValidators, OptedInValidator{ - ProviderAddr: types.NewProviderConsAddress(iterator.Key()[len(key):]), - BlockHeight: binary.BigEndian.Uint64(iterator.Value()), - }) + iterator.Value() + var optedInValidator types.OptedInValidator + if err := optedInValidator.Unmarshal(iterator.Value()); err != nil { + panic(fmt.Errorf("failed to unmarshal OptedInValidator: %w", err)) + } + optedInValidators = append(optedInValidators, optedInValidator) } return optedInValidators @@ -1264,7 +1266,8 @@ func (k Keeper) IsToBeOptedIn( return store.Get(types.ToBeOptedInKey(chainID, providerAddr)) != nil } -func (k Keeper) GetToBeOptedIn( +// GetAllToBeOptedIn returns all the to-be-opted-in validators on chain `chainID` +func (k Keeper) GetAllToBeOptedIn( ctx sdk.Context, chainID string) (addresses []types.ProviderConsAddress) { @@ -1308,7 +1311,8 @@ func (k Keeper) IsToBeOptedOut( return store.Get(types.ToBeOptedOutKey(chainID, providerAddr)) != nil } -func (k Keeper) GetToBeOptedOut( +// GetAllToBeOptedOut returns all the to-be-opted-out validators on chain `chainID` +func (k Keeper) GetAllToBeOptedOut( ctx sdk.Context, chainID string) (addresses []types.ProviderConsAddress) { diff --git a/x/ccv/provider/keeper/keeper_test.go b/x/ccv/provider/keeper/keeper_test.go index 35380a67aa..a231eb4c0c 100644 --- a/x/ccv/provider/keeper/keeper_test.go +++ b/x/ccv/provider/keeper/keeper_test.go @@ -3,7 +3,6 @@ package keeper_test import ( "bytes" "fmt" - "github.com/cosmos/interchain-security/v4/x/ccv/provider/keeper" "sort" "testing" "time" @@ -662,39 +661,49 @@ func TestTopN(t *testing.T) { } } -func TestGetOptedIn(t *testing.T) { +func TestGetAllOptedIn(t *testing.T) { providerKeeper, ctx, ctrl, _ := testkeeper.GetProviderKeeperAndCtx(t, testkeeper.NewInMemKeeperParams(t)) defer ctrl.Finish() - expectedOptedInValidators := []keeper.OptedInValidator{ + expectedOptedInValidators := []types.OptedInValidator{ { - ProviderAddr: types.NewProviderConsAddress([]byte("providerAddr1")), + ProviderAddr: []byte("providerAddr1"), BlockHeight: 1, + Power: 2, + PublicKey: []byte{3}, }, { - ProviderAddr: types.NewProviderConsAddress([]byte("providerAddr2")), + ProviderAddr: []byte("providerAddr2"), BlockHeight: 2, + Power: 3, + PublicKey: []byte{4}, }, { - ProviderAddr: types.NewProviderConsAddress([]byte("providerAddr3")), + ProviderAddr: []byte("providerAddr3"), BlockHeight: 3, + Power: 4, + PublicKey: []byte{5}, }, } for _, expectedOptedInValidator := range expectedOptedInValidators { providerKeeper.SetOptedIn(ctx, "chainID", - expectedOptedInValidator.ProviderAddr, expectedOptedInValidator.BlockHeight) + types.OptedInValidator{ + ProviderAddr: expectedOptedInValidator.ProviderAddr, + BlockHeight: expectedOptedInValidator.BlockHeight, + Power: expectedOptedInValidator.Power, + PublicKey: expectedOptedInValidator.PublicKey}) } - actualOptedInValidators := providerKeeper.GetOptedIn(ctx, "chainID") + actualOptedInValidators := providerKeeper.GetAllOptedIn(ctx, "chainID") // sort validators first to be able to compare - sortOptedInValidators := func(optedInValidators []keeper.OptedInValidator) { + sortOptedInValidators := func(optedInValidators []types.OptedInValidator) { sort.Slice(optedInValidators, func(i int, j int) bool { a := optedInValidators[i] b := optedInValidators[j] return a.BlockHeight < b.BlockHeight || - (a.BlockHeight == b.BlockHeight && bytes.Compare(a.ProviderAddr.ToSdkConsAddr(), b.ProviderAddr.ToSdkConsAddr()) < 0) + (a.BlockHeight == b.BlockHeight && bytes.Compare(a.ProviderAddr, b.ProviderAddr) < 0) }) } sortOptedInValidators(expectedOptedInValidators) @@ -707,19 +716,20 @@ func TestOptedIn(t *testing.T) { providerKeeper, ctx, ctrl, _ := testkeeper.GetProviderKeeperAndCtx(t, testkeeper.NewInMemKeeperParams(t)) defer ctrl.Finish() - optedInValidator := keeper.OptedInValidator{ - ProviderAddr: types.NewProviderConsAddress([]byte("providerAddr")), - BlockHeight: 1, + optedInValidator := types.OptedInValidator{ProviderAddr: []byte("providerAddr"), + BlockHeight: 1, + Power: 2, + PublicKey: []byte{3}, } - require.False(t, providerKeeper.IsOptedIn(ctx, "chainID", optedInValidator.ProviderAddr)) - providerKeeper.SetOptedIn(ctx, "chainID", optedInValidator.ProviderAddr, optedInValidator.BlockHeight) - require.True(t, providerKeeper.IsOptedIn(ctx, "chainID", optedInValidator.ProviderAddr)) - providerKeeper.DeleteOptedIn(ctx, "chainID", optedInValidator.ProviderAddr) - require.False(t, providerKeeper.IsOptedIn(ctx, "chainID", optedInValidator.ProviderAddr)) + require.False(t, providerKeeper.IsOptedIn(ctx, "chainID", types.NewProviderConsAddress(optedInValidator.ProviderAddr))) + providerKeeper.SetOptedIn(ctx, "chainID", optedInValidator) + require.True(t, providerKeeper.IsOptedIn(ctx, "chainID", types.NewProviderConsAddress(optedInValidator.ProviderAddr))) + providerKeeper.DeleteOptedIn(ctx, "chainID", types.NewProviderConsAddress(optedInValidator.ProviderAddr)) + require.False(t, providerKeeper.IsOptedIn(ctx, "chainID", types.NewProviderConsAddress(optedInValidator.ProviderAddr))) } -func TestGetToBeOptedIn(t *testing.T) { +func TestGetAllToBeOptedIn(t *testing.T) { providerKeeper, ctx, ctrl, _ := testkeeper.GetProviderKeeperAndCtx(t, testkeeper.NewInMemKeeperParams(t)) defer ctrl.Finish() @@ -732,7 +742,7 @@ func TestGetToBeOptedIn(t *testing.T) { providerKeeper.SetToBeOptedIn(ctx, "chainID", addr) } - actualAddresses := providerKeeper.GetToBeOptedIn(ctx, "chainID") + actualAddresses := providerKeeper.GetAllToBeOptedIn(ctx, "chainID") // sort addresses first to be able to compare sortAddresses := func(addresses []types.ProviderConsAddress) { @@ -766,7 +776,7 @@ func TestBeOptedIn(t *testing.T) { providerKeeper.SetToBeOptedIn(ctx, "chainID", addr) } - actualAddresses := providerKeeper.GetToBeOptedIn(ctx, "chainID") + actualAddresses := providerKeeper.GetAllToBeOptedIn(ctx, "chainID") // sort addresses first to be able to compare sortAddresses := func(addresses []types.ProviderConsAddress) { @@ -801,7 +811,7 @@ func TestToBeOptedIn(t *testing.T) { require.False(t, providerKeeper.IsToBeOptedIn(ctx, "chainID", providerAddr)) } -func TestGetToBeOptedOut(t *testing.T) { +func TestGetAllToBeOptedOut(t *testing.T) { providerKeeper, ctx, ctrl, _ := testkeeper.GetProviderKeeperAndCtx(t, testkeeper.NewInMemKeeperParams(t)) defer ctrl.Finish() @@ -814,7 +824,7 @@ func TestGetToBeOptedOut(t *testing.T) { providerKeeper.SetToBeOptedOut(ctx, "chainID", addr) } - actualAddresses := providerKeeper.GetToBeOptedOut(ctx, "chainID") + actualAddresses := providerKeeper.GetAllToBeOptedOut(ctx, "chainID") // sort addresses first to be able to compare sortAddresses := func(addresses []types.ProviderConsAddress) { diff --git a/x/ccv/provider/keeper/key_assignment.go b/x/ccv/provider/keeper/key_assignment.go index fc864c6417..6fbe48b41e 100644 --- a/x/ccv/provider/keeper/key_assignment.go +++ b/x/ccv/provider/keeper/key_assignment.go @@ -502,7 +502,6 @@ func (k Keeper) AssignConsumerKey( oldConsumerKey = providerKey } - // check whether the validator is valid, i.e., its power is positive power := k.stakingKeeper.GetLastValidatorPower(ctx, validator.GetOperator()) if 0 < power { // to enable multiple calls of AssignConsumerKey in the same block by the same validator @@ -568,10 +567,13 @@ func (k Keeper) MustApplyKeyAssignmentToValUpdates( // - and setting the new consumer key's power to the power in the update prevConsumerKey, _, found := k.GetKeyAssignmentReplacement(ctx, chainID, providerAddr) if found { + //if isOptedIn(providerAddr) && !isToBeOptedOut(providerAddr) { + // only generate a removal (i.e., power 0) if the validator was previously opted in newUpdates = append(newUpdates, abci.ValidatorUpdate{ PubKey: prevConsumerKey, Power: 0, }) + //} newConsumerKey, found := k.GetValidatorConsumerPubKey(ctx, chainID, providerAddr) if !found { diff --git a/x/ccv/provider/keeper/partial_set_security.go b/x/ccv/provider/keeper/partial_set_security.go index e1bf9cc14f..bf76e7d7c8 100644 --- a/x/ccv/provider/keeper/partial_set_security.go +++ b/x/ccv/provider/keeper/partial_set_security.go @@ -7,12 +7,6 @@ import ( "github.com/cosmos/interchain-security/v4/x/ccv/provider/types" ) -type OptedInValidator struct { - ProviderAddr types.ProviderConsAddress - // block height the validator opted in at - BlockHeight uint64 -} - func (k Keeper) HandleOptIn(ctx sdk.Context, chainID string, providerAddr types.ProviderConsAddress, consumerKey *string) error { if !k.IsConsumerProposedOrRegistered(ctx, chainID) { return errorsmod.Wrapf( diff --git a/x/ccv/provider/keeper/partial_set_security_test.go b/x/ccv/provider/keeper/partial_set_security_test.go index 4831723bec..1af5f58c7c 100644 --- a/x/ccv/provider/keeper/partial_set_security_test.go +++ b/x/ccv/provider/keeper/partial_set_security_test.go @@ -1,6 +1,8 @@ package keeper_test import ( + "testing" + codectypes "github.com/cosmos/cosmos-sdk/codec/types" "github.com/cosmos/cosmos-sdk/crypto/keys/ed25519" sdk "github.com/cosmos/cosmos-sdk/types" @@ -10,7 +12,6 @@ import ( ccvtypes "github.com/cosmos/interchain-security/v4/x/ccv/types" "github.com/golang/mock/gomock" "github.com/stretchr/testify/require" - "testing" ) func TestHandleOptIn(t *testing.T) { @@ -32,7 +33,9 @@ func TestHandleOptIn(t *testing.T) { require.False(t, providerKeeper.IsToBeOptedOut(ctx, "chainID", providerAddr)) // if validator (`providerAddr`) is already opted in, then the validator cannot be opted in - providerKeeper.SetOptedIn(ctx, "chainID", providerAddr, 1) + + providerKeeper.SetOptedIn(ctx, "chainID", + types.OptedInValidator{ProviderAddr: providerAddr.ToSdkConsAddr(), BlockHeight: 1, Power: 1, PublicKey: []byte{1}}) providerKeeper.HandleOptIn(ctx, "chainID", providerAddr, nil) require.False(t, providerKeeper.IsToBeOptedIn(ctx, "chainID", providerAddr)) } diff --git a/x/ccv/provider/types/keys.go b/x/ccv/provider/types/keys.go index ed86ea0804..9fb9fc9caf 100644 --- a/x/ccv/provider/types/keys.go +++ b/x/ccv/provider/types/keys.go @@ -542,9 +542,9 @@ func TopNKey(chainID string) []byte { } // OptedInKey returns the key of consumer chain `chainID` and validator with `providerAddr` -func OptedInKey(chainID string, providerAddr ProviderConsAddress) []byte { +func OptedInKey(chainID string, providerAddr []byte) []byte { prefix := ChainIdWithLenKey(OptedInBytePrefix, chainID) - return append(prefix, providerAddr.ToSdkConsAddr().Bytes()...) + return append(prefix, providerAddr...) } // ToBeOptedInKey returns the key of consumer chain `chainID` and validator with `providerAddr` diff --git a/x/ccv/provider/types/provider.pb.go b/x/ccv/provider/types/provider.pb.go index 20733b4fa0..6e1a361df9 100644 --- a/x/ccv/provider/types/provider.pb.go +++ b/x/ccv/provider/types/provider.pb.go @@ -1392,7 +1392,9 @@ func (m *ConsumerAddrsToPrune) GetConsumerAddrs() *AddressList { return nil } -// ConsumerRewardsAllocation is used to serialize the allocation of consumer chain rewards +// ConsumerRewardsAllocation stores the rewards allocated by a consumer chain +// to the consumer rewards pool. It is used to allocate the tokens to the consumer +// opted-in validators and the community pool during BeginBlock. type ConsumerRewardsAllocation struct { Rewards github_com_cosmos_cosmos_sdk_types.DecCoins `protobuf:"bytes,1,rep,name=rewards,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.DecCoins" json:"rewards"` } @@ -1437,6 +1439,80 @@ func (m *ConsumerRewardsAllocation) GetRewards() github_com_cosmos_cosmos_sdk_ty return nil } +// OptedInValidator is used to store a opted-in validator +// to a consumer chain with the following mapping: (chainID, providerAddr) -> optedInValidator +type OptedInValidator struct { + // validator address + ProviderAddr []byte `protobuf:"bytes,1,opt,name=provider_addr,json=providerAddr,proto3" json:"provider_addr,omitempty"` + // block height at which the validator opted-in + BlockHeight int64 `protobuf:"varint,2,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"` + // validator voting power at the block it opted-in + Power int64 `protobuf:"varint,3,opt,name=power,proto3" json:"power,omitempty"` + // public key used by the validator on the consumer + PublicKey []byte `protobuf:"bytes,4,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"` +} + +func (m *OptedInValidator) Reset() { *m = OptedInValidator{} } +func (m *OptedInValidator) String() string { return proto.CompactTextString(m) } +func (*OptedInValidator) ProtoMessage() {} +func (*OptedInValidator) Descriptor() ([]byte, []int) { + return fileDescriptor_f22ec409a72b7b72, []int{23} +} +func (m *OptedInValidator) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *OptedInValidator) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_OptedInValidator.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 *OptedInValidator) XXX_Merge(src proto.Message) { + xxx_messageInfo_OptedInValidator.Merge(m, src) +} +func (m *OptedInValidator) XXX_Size() int { + return m.Size() +} +func (m *OptedInValidator) XXX_DiscardUnknown() { + xxx_messageInfo_OptedInValidator.DiscardUnknown(m) +} + +var xxx_messageInfo_OptedInValidator proto.InternalMessageInfo + +func (m *OptedInValidator) GetProviderAddr() []byte { + if m != nil { + return m.ProviderAddr + } + return nil +} + +func (m *OptedInValidator) GetBlockHeight() int64 { + if m != nil { + return m.BlockHeight + } + return 0 +} + +func (m *OptedInValidator) GetPower() int64 { + if m != nil { + return m.Power + } + return 0 +} + +func (m *OptedInValidator) GetPublicKey() []byte { + if m != nil { + return m.PublicKey + } + return nil +} + func init() { proto.RegisterType((*ConsumerAdditionProposal)(nil), "interchain_security.ccv.provider.v1.ConsumerAdditionProposal") proto.RegisterType((*ConsumerRemovalProposal)(nil), "interchain_security.ccv.provider.v1.ConsumerRemovalProposal") @@ -1461,6 +1537,7 @@ func init() { proto.RegisterType((*ValidatorByConsumerAddr)(nil), "interchain_security.ccv.provider.v1.ValidatorByConsumerAddr") proto.RegisterType((*ConsumerAddrsToPrune)(nil), "interchain_security.ccv.provider.v1.ConsumerAddrsToPrune") proto.RegisterType((*ConsumerRewardsAllocation)(nil), "interchain_security.ccv.provider.v1.ConsumerRewardsAllocation") + proto.RegisterType((*OptedInValidator)(nil), "interchain_security.ccv.provider.v1.OptedInValidator") } func init() { @@ -1468,119 +1545,122 @@ func init() { } var fileDescriptor_f22ec409a72b7b72 = []byte{ - // 1787 bytes of a gzipped FileDescriptorProto + // 1833 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x58, 0xcd, 0x73, 0x1c, 0x47, 0x15, 0xd7, 0x68, 0x57, 0x1f, 0xfb, 0x56, 0x9f, 0x23, 0x25, 0x1e, 0x19, 0xb1, 0x92, 0x27, 0x24, 0x08, 0x5c, 0x9e, 0x41, 0x0a, 0x54, 0xb9, 0x5c, 0xa4, 0x52, 0xd2, 0xca, 0x89, 0x65, 0x11, 0x5b, 0x19, 0x09, 0xb9, 0x80, 0xc3, 0x54, 0x6f, 0x4f, 0x7b, 0xb7, 0x4b, 0xb3, 0xd3, 0xe3, 0xee, 0xde, - 0x71, 0xf6, 0xc2, 0x99, 0x0b, 0x55, 0xe1, 0x96, 0xe2, 0x42, 0xe0, 0x44, 0x71, 0x81, 0x2b, 0xff, - 0x41, 0x8e, 0x39, 0x72, 0x4a, 0x28, 0xfb, 0xc0, 0x81, 0x2b, 0x7f, 0x00, 0xd5, 0x3d, 0x9f, 0xbb, - 0x92, 0xcc, 0xba, 0x42, 0x2e, 0xd2, 0xcc, 0xeb, 0xf7, 0x7e, 0xef, 0x75, 0xbf, 0xf7, 0x7e, 0xaf, - 0x77, 0x60, 0x8f, 0x46, 0x92, 0x70, 0xdc, 0x43, 0x34, 0xf2, 0x05, 0xc1, 0x03, 0x4e, 0xe5, 0xd0, - 0xc5, 0x38, 0x71, 0x63, 0xce, 0x12, 0x1a, 0x10, 0xee, 0x26, 0xbb, 0xc5, 0xb3, 0x13, 0x73, 0x26, - 0x99, 0xf9, 0xd6, 0x15, 0x36, 0x0e, 0xc6, 0x89, 0x53, 0xe8, 0x25, 0xbb, 0x37, 0xdf, 0xbe, 0x0e, - 0x38, 0xd9, 0x75, 0x9f, 0x53, 0x4e, 0x52, 0xac, 0x9b, 0xeb, 0x5d, 0xd6, 0x65, 0xfa, 0xd1, 0x55, - 0x4f, 0x99, 0x74, 0xab, 0xcb, 0x58, 0x37, 0x24, 0xae, 0x7e, 0xeb, 0x0c, 0x9e, 0xba, 0x92, 0xf6, - 0x89, 0x90, 0xa8, 0x1f, 0x67, 0x0a, 0xad, 0x71, 0x85, 0x60, 0xc0, 0x91, 0xa4, 0x2c, 0xca, 0x01, - 0x68, 0x07, 0xbb, 0x98, 0x71, 0xe2, 0xe2, 0x90, 0x92, 0x48, 0x2a, 0xaf, 0xe9, 0x53, 0xa6, 0xe0, - 0x2a, 0x85, 0x90, 0x76, 0x7b, 0x32, 0x15, 0x0b, 0x57, 0x92, 0x28, 0x20, 0xbc, 0x4f, 0x53, 0xe5, - 0xf2, 0x2d, 0x33, 0xd8, 0xac, 0xac, 0x63, 0x3e, 0x8c, 0x25, 0x73, 0x2f, 0xc8, 0x50, 0x64, 0xab, - 0xef, 0x60, 0x26, 0xfa, 0x4c, 0xb8, 0x44, 0xed, 0x3f, 0xc2, 0xc4, 0x4d, 0x76, 0x3b, 0x44, 0xa2, - 0xdd, 0x42, 0x90, 0xc7, 0x9d, 0xe9, 0x75, 0x90, 0x28, 0x75, 0x30, 0xa3, 0x79, 0xdc, 0xab, 0xa8, - 0x4f, 0x23, 0xe6, 0xea, 0xbf, 0xa9, 0xc8, 0xfe, 0xcf, 0x2c, 0x58, 0x6d, 0x16, 0x89, 0x41, 0x9f, - 0xf0, 0xfd, 0x20, 0xa0, 0x6a, 0x97, 0x27, 0x9c, 0xc5, 0x4c, 0xa0, 0xd0, 0x5c, 0x87, 0x19, 0x49, - 0x65, 0x48, 0x2c, 0x63, 0xdb, 0xd8, 0x69, 0x78, 0xe9, 0x8b, 0xb9, 0x0d, 0xcd, 0x80, 0x08, 0xcc, - 0x69, 0xac, 0x94, 0xad, 0x69, 0xbd, 0x56, 0x15, 0x99, 0x1b, 0x30, 0x9f, 0xa6, 0x86, 0x06, 0x56, - 0x4d, 0x2f, 0xcf, 0xe9, 0xf7, 0xa3, 0xc0, 0xfc, 0x10, 0x96, 0x68, 0x44, 0x25, 0x45, 0xa1, 0xdf, - 0x23, 0xea, 0x80, 0xac, 0xfa, 0xb6, 0xb1, 0xd3, 0xdc, 0xbb, 0xe9, 0xd0, 0x0e, 0x76, 0xd4, 0x99, - 0x3a, 0xd9, 0x49, 0x26, 0xbb, 0xce, 0x03, 0xad, 0x71, 0x50, 0xff, 0xe2, 0xab, 0xad, 0x29, 0x6f, - 0x31, 0xb3, 0x4b, 0x85, 0xe6, 0x2d, 0x58, 0xe8, 0x92, 0x88, 0x08, 0x2a, 0xfc, 0x1e, 0x12, 0x3d, - 0x6b, 0x66, 0xdb, 0xd8, 0x59, 0xf0, 0x9a, 0x99, 0xec, 0x01, 0x12, 0x3d, 0x73, 0x0b, 0x9a, 0x1d, - 0x1a, 0x21, 0x3e, 0x4c, 0x35, 0x66, 0xb5, 0x06, 0xa4, 0x22, 0xad, 0xd0, 0x06, 0x10, 0x31, 0x7a, - 0x1e, 0xf9, 0xaa, 0x00, 0xac, 0xb9, 0x2c, 0x90, 0x34, 0xf9, 0x4e, 0x9e, 0x7c, 0xe7, 0x2c, 0xaf, - 0x8e, 0x83, 0x79, 0x15, 0xc8, 0xa7, 0x5f, 0x6f, 0x19, 0x5e, 0x43, 0xdb, 0xa9, 0x15, 0xf3, 0x11, - 0xac, 0x0c, 0xa2, 0x0e, 0x8b, 0x02, 0x1a, 0x75, 0xfd, 0x98, 0x70, 0xca, 0x02, 0x6b, 0x5e, 0x43, - 0x6d, 0x5c, 0x82, 0x3a, 0xcc, 0xea, 0x28, 0x45, 0xfa, 0x4c, 0x21, 0x2d, 0x17, 0xc6, 0x27, 0xda, - 0xd6, 0xfc, 0x18, 0x4c, 0x8c, 0x13, 0x1d, 0x12, 0x1b, 0xc8, 0x1c, 0xb1, 0x31, 0x39, 0xe2, 0x0a, - 0xc6, 0xc9, 0x59, 0x6a, 0x9d, 0x41, 0xfe, 0x0a, 0x6e, 0x48, 0x8e, 0x22, 0xf1, 0x94, 0xf0, 0x71, - 0x5c, 0x98, 0x1c, 0xf7, 0x8d, 0x1c, 0x63, 0x14, 0xfc, 0x01, 0x6c, 0xe3, 0xac, 0x80, 0x7c, 0x4e, - 0x02, 0x2a, 0x24, 0xa7, 0x9d, 0x81, 0xb2, 0xf5, 0x9f, 0x72, 0x84, 0x75, 0x8d, 0x34, 0x75, 0x11, - 0xb4, 0x72, 0x3d, 0x6f, 0x44, 0xed, 0x83, 0x4c, 0xcb, 0x7c, 0x0c, 0xdf, 0xeb, 0x84, 0x0c, 0x5f, - 0x08, 0x15, 0x9c, 0x3f, 0x82, 0xa4, 0x5d, 0xf7, 0xa9, 0x10, 0x0a, 0x6d, 0x61, 0xdb, 0xd8, 0xa9, - 0x79, 0xb7, 0x52, 0xdd, 0x13, 0xc2, 0x0f, 0x2b, 0x9a, 0x67, 0x15, 0x45, 0xf3, 0x0e, 0x98, 0x3d, - 0x2a, 0x24, 0xe3, 0x14, 0xa3, 0xd0, 0x27, 0x91, 0xe4, 0x94, 0x08, 0x6b, 0x51, 0x9b, 0xaf, 0x96, - 0x2b, 0xf7, 0xd3, 0x05, 0xf3, 0x21, 0xdc, 0xba, 0xd6, 0xa9, 0x8f, 0x7b, 0x28, 0x8a, 0x48, 0x68, - 0x2d, 0xe9, 0xad, 0x6c, 0x05, 0xd7, 0xf8, 0x6c, 0xa7, 0x6a, 0xe6, 0x1a, 0xcc, 0x48, 0x16, 0xfb, - 0x8f, 0xac, 0xe5, 0x6d, 0x63, 0x67, 0xd1, 0xab, 0x4b, 0x16, 0x3f, 0xba, 0x37, 0xff, 0x9b, 0xcf, - 0xb7, 0xa6, 0x3e, 0xfb, 0x7c, 0x6b, 0xca, 0xfe, 0xab, 0x01, 0x37, 0xda, 0xc5, 0x69, 0xf4, 0x59, - 0x82, 0xc2, 0x6f, 0xb3, 0xeb, 0xf6, 0xa1, 0x21, 0x54, 0x38, 0xba, 0xce, 0xeb, 0xaf, 0x51, 0xe7, - 0xf3, 0xca, 0x4c, 0x2d, 0xd8, 0x7f, 0x30, 0x60, 0xfd, 0xfe, 0xb3, 0x01, 0x4d, 0x18, 0x46, 0xff, - 0x17, 0x92, 0x38, 0x86, 0x45, 0x52, 0xc1, 0x13, 0x56, 0x6d, 0xbb, 0xb6, 0xd3, 0xdc, 0x7b, 0xdb, - 0x49, 0x49, 0xcc, 0x29, 0xb8, 0x2d, 0x23, 0x32, 0xa7, 0xea, 0xdd, 0x1b, 0xb5, 0xbd, 0x37, 0x6d, - 0x19, 0xf6, 0x9f, 0x0c, 0xb8, 0xa9, 0x8e, 0xbf, 0x4b, 0x3c, 0xf2, 0x1c, 0xf1, 0xe0, 0x90, 0x44, - 0xac, 0x2f, 0xbe, 0x71, 0x9c, 0x36, 0x2c, 0x06, 0x1a, 0xc9, 0x97, 0xcc, 0x47, 0x41, 0xa0, 0xe3, - 0xd4, 0x3a, 0x4a, 0x78, 0xc6, 0xf6, 0x83, 0xc0, 0xdc, 0x81, 0x95, 0x52, 0x87, 0xab, 0x7c, 0xaa, - 0x63, 0x56, 0x6a, 0x4b, 0xb9, 0x9a, 0xce, 0x32, 0xb1, 0xff, 0x6d, 0xc0, 0xca, 0x87, 0x21, 0xeb, - 0xa0, 0xf0, 0x34, 0x44, 0xa2, 0xa7, 0x4a, 0x6f, 0xa8, 0xd2, 0xc3, 0x49, 0xd6, 0xf3, 0x3a, 0xbc, - 0x89, 0xd3, 0xa3, 0xcc, 0x34, 0x0b, 0xbd, 0x0f, 0xab, 0x45, 0x17, 0x16, 0x55, 0xa0, 0x77, 0x73, - 0xb0, 0xf6, 0xe2, 0xab, 0xad, 0xe5, 0xbc, 0xd8, 0xda, 0xba, 0x22, 0x0e, 0xbd, 0x65, 0x3c, 0x22, - 0x08, 0xcc, 0x16, 0x34, 0x69, 0x07, 0xfb, 0x82, 0x3c, 0xf3, 0xa3, 0x41, 0x5f, 0x17, 0x50, 0xdd, - 0x6b, 0xd0, 0x0e, 0x3e, 0x25, 0xcf, 0x1e, 0x0d, 0xfa, 0xe6, 0xbb, 0xf0, 0x66, 0x3e, 0x80, 0xfd, - 0x04, 0x85, 0xbe, 0xb2, 0x57, 0xc7, 0xc1, 0x75, 0x3d, 0x2d, 0x78, 0x6b, 0xf9, 0xea, 0x39, 0x0a, - 0x95, 0xb3, 0xfd, 0x20, 0xe0, 0xf6, 0xdf, 0x67, 0x60, 0xf6, 0x04, 0x71, 0xd4, 0x17, 0xe6, 0x19, - 0x2c, 0x4b, 0xd2, 0x8f, 0x43, 0x24, 0x89, 0x9f, 0x32, 0x7c, 0xb6, 0xd3, 0xdb, 0x9a, 0xf9, 0xab, - 0xc3, 0xd2, 0xa9, 0x8c, 0xc7, 0x64, 0xd7, 0x69, 0x6b, 0xe9, 0xa9, 0x44, 0x92, 0x78, 0x4b, 0x39, - 0x46, 0x2a, 0x34, 0xef, 0x82, 0x25, 0xf9, 0x40, 0xc8, 0x92, 0x7b, 0x4b, 0xd2, 0x49, 0x73, 0xf9, - 0x66, 0xbe, 0x9e, 0xd2, 0x55, 0x41, 0x36, 0x57, 0xd3, 0x6c, 0xed, 0x9b, 0xd0, 0xec, 0x29, 0xac, - 0xa9, 0x19, 0x35, 0x8e, 0x59, 0x9f, 0x1c, 0x73, 0x55, 0xd9, 0x8f, 0x82, 0x7e, 0x0c, 0x66, 0x22, - 0xf0, 0x38, 0xe6, 0xcc, 0x6b, 0xc4, 0x99, 0x08, 0x3c, 0x0a, 0x19, 0xc0, 0xa6, 0x50, 0xc5, 0xe7, - 0xf7, 0x89, 0xd4, 0xa4, 0x1d, 0x87, 0x24, 0xa2, 0xa2, 0x97, 0x83, 0xcf, 0x4e, 0x0e, 0xbe, 0xa1, - 0x81, 0x3e, 0x52, 0x38, 0x5e, 0x0e, 0x93, 0x79, 0x69, 0x43, 0xeb, 0x6a, 0x2f, 0x45, 0x82, 0xe6, - 0x74, 0x82, 0xbe, 0x73, 0x05, 0x44, 0x91, 0x25, 0x01, 0xef, 0x54, 0x86, 0x8b, 0xea, 0x6a, 0x5f, - 0x37, 0x94, 0xcf, 0x49, 0x57, 0x31, 0x30, 0x4a, 0xe7, 0x0c, 0x21, 0xc5, 0x80, 0xcc, 0xd8, 0x43, - 0x5d, 0x81, 0x0a, 0xe6, 0x68, 0x33, 0x1a, 0x65, 0xb7, 0x08, 0xbb, 0x9c, 0x41, 0x05, 0x47, 0x78, - 0x15, 0xac, 0x0f, 0x08, 0x79, 0x58, 0x9f, 0x9f, 0x5f, 0x69, 0xd8, 0x3f, 0x80, 0x86, 0x6e, 0xd1, - 0x7d, 0x7c, 0x21, 0xcc, 0x4d, 0x68, 0xa8, 0x5a, 0x27, 0x42, 0x10, 0x61, 0x19, 0xba, 0xb3, 0x4b, - 0x81, 0x2d, 0x61, 0xe3, 0xba, 0x3b, 0x94, 0x30, 0x9f, 0xc0, 0x5c, 0x4c, 0xf4, 0x80, 0xd7, 0x86, - 0xcd, 0xbd, 0xf7, 0x9c, 0x09, 0x6e, 0xb8, 0xce, 0x75, 0x80, 0x5e, 0x8e, 0x66, 0xf3, 0xf2, 0xe6, - 0x36, 0x36, 0x42, 0x84, 0x79, 0x3e, 0xee, 0xf4, 0xa7, 0xaf, 0xe5, 0x74, 0x0c, 0xaf, 0xf4, 0x79, - 0x1b, 0x9a, 0xfb, 0xe9, 0xb6, 0x7f, 0x46, 0x85, 0xbc, 0x7c, 0x2c, 0x0b, 0xd5, 0x63, 0x79, 0x08, - 0x4b, 0xd9, 0x38, 0x3c, 0x63, 0x9a, 0x66, 0xcc, 0xef, 0x02, 0x64, 0x73, 0x54, 0xd1, 0x53, 0x4a, - 0xc4, 0x8d, 0x4c, 0x72, 0x14, 0x8c, 0x4c, 0xb0, 0xe9, 0x91, 0x09, 0x66, 0x7b, 0xb0, 0x7c, 0x2e, - 0xf0, 0xcf, 0xf3, 0xbb, 0xd2, 0xe3, 0x58, 0x98, 0x6f, 0xc0, 0xac, 0xea, 0x8c, 0x0c, 0xa8, 0xee, - 0xcd, 0x24, 0x02, 0x1f, 0x69, 0x2e, 0x2e, 0xef, 0x63, 0x2c, 0xf6, 0x69, 0x20, 0xac, 0xe9, 0xed, - 0xda, 0x4e, 0xdd, 0x5b, 0x1a, 0x94, 0xe6, 0x47, 0x81, 0xb0, 0x7f, 0x01, 0xcd, 0x0a, 0xa0, 0xb9, - 0x04, 0xd3, 0x05, 0xd6, 0x34, 0x0d, 0xcc, 0x7b, 0xb0, 0x51, 0x02, 0x8d, 0x92, 0x6b, 0x8a, 0xd8, - 0xf0, 0x6e, 0x14, 0x0a, 0x23, 0xfc, 0x2a, 0xec, 0xc7, 0xb0, 0x7e, 0x54, 0xb6, 0x72, 0x41, 0xdd, - 0x23, 0x3b, 0x34, 0x46, 0x67, 0xf4, 0x26, 0x34, 0x8a, 0xdf, 0x21, 0x7a, 0xf7, 0x75, 0xaf, 0x14, - 0xd8, 0x7d, 0x58, 0x39, 0x17, 0xf8, 0x94, 0x44, 0x41, 0x09, 0x76, 0xcd, 0x01, 0x1c, 0x8c, 0x03, - 0x4d, 0x7c, 0xa9, 0x2d, 0xdd, 0x31, 0xd8, 0x38, 0x47, 0x21, 0x0d, 0x90, 0x64, 0xfc, 0x94, 0xc8, - 0x74, 0xac, 0x9e, 0x20, 0x7c, 0x41, 0xa4, 0x30, 0x3d, 0xa8, 0x87, 0x54, 0xc8, 0xac, 0xb2, 0xee, - 0x5e, 0x5b, 0x59, 0xc9, 0xae, 0x73, 0x1d, 0xc8, 0x21, 0x92, 0x28, 0xeb, 0x48, 0x8d, 0x65, 0x7f, - 0x1f, 0xd6, 0x3e, 0x42, 0x72, 0xc0, 0x49, 0x30, 0x92, 0xe3, 0x15, 0xa8, 0xa9, 0xfc, 0x19, 0x3a, - 0x7f, 0xea, 0x51, 0x4d, 0x79, 0xeb, 0xfe, 0x27, 0x31, 0xe3, 0x92, 0x04, 0x97, 0x4e, 0xe4, 0x15, - 0xc7, 0x7b, 0x01, 0x6b, 0xea, 0xb0, 0x04, 0x89, 0x02, 0xbf, 0xd8, 0x67, 0x9a, 0xc7, 0xe6, 0xde, - 0x4f, 0x26, 0xea, 0x8e, 0x71, 0x77, 0xd9, 0x06, 0x56, 0x93, 0x31, 0xb9, 0xb0, 0x7f, 0x67, 0x80, - 0x75, 0x4c, 0x86, 0xfb, 0x42, 0xd0, 0x6e, 0xd4, 0x27, 0x91, 0x54, 0xcc, 0x86, 0x30, 0x51, 0x8f, - 0xe6, 0x5b, 0xb0, 0x58, 0x4c, 0x52, 0x3d, 0x40, 0x0d, 0x3d, 0x40, 0x17, 0x72, 0xa1, 0x6a, 0x30, - 0xf3, 0x1e, 0x40, 0xcc, 0x49, 0xe2, 0x63, 0xff, 0x82, 0x0c, 0xb3, 0x2c, 0x6e, 0x56, 0x07, 0x63, - 0xfa, 0x2b, 0xd1, 0x39, 0x19, 0x74, 0x42, 0x8a, 0x8f, 0xc9, 0xd0, 0x9b, 0x57, 0xfa, 0xed, 0x63, - 0x32, 0x54, 0x37, 0x9d, 0x98, 0x3d, 0x27, 0x5c, 0x4f, 0xb3, 0x9a, 0x97, 0xbe, 0xd8, 0xbf, 0x37, - 0xe0, 0x46, 0x91, 0x8e, 0xbc, 0x5c, 0x4f, 0x06, 0x1d, 0x65, 0xf1, 0x8a, 0x73, 0xbb, 0x14, 0xed, - 0xf4, 0x15, 0xd1, 0xbe, 0x0f, 0x0b, 0x45, 0x83, 0xa8, 0x78, 0x6b, 0x13, 0xc4, 0xdb, 0xcc, 0x2d, - 0x8e, 0xc9, 0xd0, 0xfe, 0x75, 0x25, 0xb6, 0x83, 0x61, 0x85, 0xfb, 0xf8, 0xff, 0x88, 0xad, 0x70, - 0x5b, 0x8d, 0x0d, 0x57, 0xed, 0x2f, 0x6d, 0xa0, 0x76, 0x79, 0x03, 0xf6, 0x1f, 0x0d, 0x58, 0xaf, - 0x7a, 0x15, 0x67, 0xec, 0x84, 0x0f, 0x22, 0xf2, 0x2a, 0xef, 0x65, 0xfb, 0x4d, 0x57, 0xdb, 0xef, - 0x09, 0x2c, 0x8d, 0x04, 0x25, 0xb2, 0xd3, 0xf8, 0xd1, 0x44, 0x35, 0x56, 0x61, 0x57, 0x6f, 0xb1, - 0xba, 0x0f, 0x61, 0xff, 0xd6, 0x28, 0xc7, 0x4c, 0x3a, 0xbd, 0xc4, 0x7e, 0x18, 0x66, 0x57, 0x60, - 0x33, 0x86, 0xb9, 0x74, 0x40, 0x8a, 0xac, 0x2f, 0x37, 0xaf, 0x1c, 0x85, 0x87, 0x04, 0xeb, 0x69, - 0x78, 0x57, 0x95, 0xee, 0x5f, 0xbe, 0xde, 0xba, 0xdd, 0xa5, 0xb2, 0x37, 0xe8, 0x38, 0x98, 0xf5, - 0xdd, 0xec, 0xeb, 0x41, 0xfa, 0xef, 0x8e, 0x08, 0x2e, 0x5c, 0x39, 0x8c, 0x89, 0xc8, 0x6d, 0xc4, - 0x9f, 0xff, 0xf5, 0xb7, 0x1f, 0x1a, 0x5e, 0xee, 0xe6, 0xe0, 0xc9, 0x17, 0x2f, 0x5a, 0xc6, 0x97, - 0x2f, 0x5a, 0xc6, 0x3f, 0x5f, 0xb4, 0x8c, 0x4f, 0x5f, 0xb6, 0xa6, 0xbe, 0x7c, 0xd9, 0x9a, 0xfa, - 0xc7, 0xcb, 0xd6, 0xd4, 0x2f, 0xdf, 0xbb, 0x0c, 0x5a, 0xee, 0xfd, 0x4e, 0xf1, 0xbd, 0x26, 0xf9, - 0xb1, 0xfb, 0xc9, 0xe8, 0xd7, 0x20, 0xed, 0xaf, 0x33, 0xab, 0x59, 0xea, 0xdd, 0xff, 0x06, 0x00, - 0x00, 0xff, 0xff, 0x2a, 0x2c, 0xd4, 0x2e, 0x3e, 0x12, 0x00, 0x00, + 0x71, 0xf6, 0xc2, 0x99, 0x0b, 0x45, 0xb8, 0xa5, 0xb8, 0x10, 0x38, 0x51, 0x5c, 0xe0, 0xca, 0x7f, + 0x90, 0x63, 0x8e, 0x9c, 0x12, 0xca, 0x3e, 0x70, 0xe0, 0xca, 0x1f, 0x40, 0x75, 0xcf, 0xe7, 0xae, + 0x24, 0xb3, 0xae, 0xc0, 0x45, 0x9a, 0x79, 0xfd, 0xde, 0xef, 0x7d, 0xbf, 0xd7, 0x3b, 0xb0, 0x47, + 0x23, 0x49, 0x38, 0xee, 0x21, 0x1a, 0xf9, 0x82, 0xe0, 0x01, 0xa7, 0x72, 0xe8, 0x62, 0x9c, 0xb8, + 0x31, 0x67, 0x09, 0x0d, 0x08, 0x77, 0x93, 0xdd, 0xe2, 0xd9, 0x89, 0x39, 0x93, 0xcc, 0x7c, 0xeb, + 0x0a, 0x19, 0x07, 0xe3, 0xc4, 0x29, 0xf8, 0x92, 0xdd, 0x9b, 0x6f, 0x5f, 0x07, 0x9c, 0xec, 0xba, + 0xcf, 0x29, 0x27, 0x29, 0xd6, 0xcd, 0xf5, 0x2e, 0xeb, 0x32, 0xfd, 0xe8, 0xaa, 0xa7, 0x8c, 0xba, + 0xd5, 0x65, 0xac, 0x1b, 0x12, 0x57, 0xbf, 0x75, 0x06, 0x4f, 0x5d, 0x49, 0xfb, 0x44, 0x48, 0xd4, + 0x8f, 0x33, 0x86, 0xd6, 0x38, 0x43, 0x30, 0xe0, 0x48, 0x52, 0x16, 0xe5, 0x00, 0xb4, 0x83, 0x5d, + 0xcc, 0x38, 0x71, 0x71, 0x48, 0x49, 0x24, 0x95, 0xd6, 0xf4, 0x29, 0x63, 0x70, 0x15, 0x43, 0x48, + 0xbb, 0x3d, 0x99, 0x92, 0x85, 0x2b, 0x49, 0x14, 0x10, 0xde, 0xa7, 0x29, 0x73, 0xf9, 0x96, 0x09, + 0x6c, 0x56, 0xce, 0x31, 0x1f, 0xc6, 0x92, 0xb9, 0x17, 0x64, 0x28, 0xb2, 0xd3, 0x77, 0x30, 0x13, + 0x7d, 0x26, 0x5c, 0xa2, 0xfc, 0x8f, 0x30, 0x71, 0x93, 0xdd, 0x0e, 0x91, 0x68, 0xb7, 0x20, 0xe4, + 0x76, 0x67, 0x7c, 0x1d, 0x24, 0x4a, 0x1e, 0xcc, 0x68, 0x6e, 0xf7, 0x2a, 0xea, 0xd3, 0x88, 0xb9, + 0xfa, 0x6f, 0x4a, 0xb2, 0xff, 0x3d, 0x0b, 0x56, 0x9b, 0x45, 0x62, 0xd0, 0x27, 0x7c, 0x3f, 0x08, + 0xa8, 0xf2, 0xf2, 0x84, 0xb3, 0x98, 0x09, 0x14, 0x9a, 0xeb, 0x30, 0x23, 0xa9, 0x0c, 0x89, 0x65, + 0x6c, 0x1b, 0x3b, 0x0d, 0x2f, 0x7d, 0x31, 0xb7, 0xa1, 0x19, 0x10, 0x81, 0x39, 0x8d, 0x15, 0xb3, + 0x35, 0xad, 0xcf, 0xaa, 0x24, 0x73, 0x03, 0xe6, 0xd3, 0xd4, 0xd0, 0xc0, 0xaa, 0xe9, 0xe3, 0x39, + 0xfd, 0x7e, 0x14, 0x98, 0x1f, 0xc2, 0x12, 0x8d, 0xa8, 0xa4, 0x28, 0xf4, 0x7b, 0x44, 0x05, 0xc8, + 0xaa, 0x6f, 0x1b, 0x3b, 0xcd, 0xbd, 0x9b, 0x0e, 0xed, 0x60, 0x47, 0xc5, 0xd4, 0xc9, 0x22, 0x99, + 0xec, 0x3a, 0x0f, 0x34, 0xc7, 0x41, 0xfd, 0x8b, 0xaf, 0xb6, 0xa6, 0xbc, 0xc5, 0x4c, 0x2e, 0x25, + 0x9a, 0xb7, 0x60, 0xa1, 0x4b, 0x22, 0x22, 0xa8, 0xf0, 0x7b, 0x48, 0xf4, 0xac, 0x99, 0x6d, 0x63, + 0x67, 0xc1, 0x6b, 0x66, 0xb4, 0x07, 0x48, 0xf4, 0xcc, 0x2d, 0x68, 0x76, 0x68, 0x84, 0xf8, 0x30, + 0xe5, 0x98, 0xd5, 0x1c, 0x90, 0x92, 0x34, 0x43, 0x1b, 0x40, 0xc4, 0xe8, 0x79, 0xe4, 0xab, 0x02, + 0xb0, 0xe6, 0x32, 0x43, 0xd2, 0xe4, 0x3b, 0x79, 0xf2, 0x9d, 0xb3, 0xbc, 0x3a, 0x0e, 0xe6, 0x95, + 0x21, 0x9f, 0x7e, 0xbd, 0x65, 0x78, 0x0d, 0x2d, 0xa7, 0x4e, 0xcc, 0x47, 0xb0, 0x32, 0x88, 0x3a, + 0x2c, 0x0a, 0x68, 0xd4, 0xf5, 0x63, 0xc2, 0x29, 0x0b, 0xac, 0x79, 0x0d, 0xb5, 0x71, 0x09, 0xea, + 0x30, 0xab, 0xa3, 0x14, 0xe9, 0x33, 0x85, 0xb4, 0x5c, 0x08, 0x9f, 0x68, 0x59, 0xf3, 0x63, 0x30, + 0x31, 0x4e, 0xb4, 0x49, 0x6c, 0x20, 0x73, 0xc4, 0xc6, 0xe4, 0x88, 0x2b, 0x18, 0x27, 0x67, 0xa9, + 0x74, 0x06, 0xf9, 0x0b, 0xb8, 0x21, 0x39, 0x8a, 0xc4, 0x53, 0xc2, 0xc7, 0x71, 0x61, 0x72, 0xdc, + 0x37, 0x72, 0x8c, 0x51, 0xf0, 0x07, 0xb0, 0x8d, 0xb3, 0x02, 0xf2, 0x39, 0x09, 0xa8, 0x90, 0x9c, + 0x76, 0x06, 0x4a, 0xd6, 0x7f, 0xca, 0x11, 0xd6, 0x35, 0xd2, 0xd4, 0x45, 0xd0, 0xca, 0xf9, 0xbc, + 0x11, 0xb6, 0x0f, 0x32, 0x2e, 0xf3, 0x31, 0x7c, 0xa7, 0x13, 0x32, 0x7c, 0x21, 0x94, 0x71, 0xfe, + 0x08, 0x92, 0x56, 0xdd, 0xa7, 0x42, 0x28, 0xb4, 0x85, 0x6d, 0x63, 0xa7, 0xe6, 0xdd, 0x4a, 0x79, + 0x4f, 0x08, 0x3f, 0xac, 0x70, 0x9e, 0x55, 0x18, 0xcd, 0x3b, 0x60, 0xf6, 0xa8, 0x90, 0x8c, 0x53, + 0x8c, 0x42, 0x9f, 0x44, 0x92, 0x53, 0x22, 0xac, 0x45, 0x2d, 0xbe, 0x5a, 0x9e, 0xdc, 0x4f, 0x0f, + 0xcc, 0x87, 0x70, 0xeb, 0x5a, 0xa5, 0x3e, 0xee, 0xa1, 0x28, 0x22, 0xa1, 0xb5, 0xa4, 0x5d, 0xd9, + 0x0a, 0xae, 0xd1, 0xd9, 0x4e, 0xd9, 0xcc, 0x35, 0x98, 0x91, 0x2c, 0xf6, 0x1f, 0x59, 0xcb, 0xdb, + 0xc6, 0xce, 0xa2, 0x57, 0x97, 0x2c, 0x7e, 0x74, 0x6f, 0xfe, 0x57, 0x9f, 0x6f, 0x4d, 0x7d, 0xf6, + 0xf9, 0xd6, 0x94, 0xfd, 0x17, 0x03, 0x6e, 0xb4, 0x8b, 0x68, 0xf4, 0x59, 0x82, 0xc2, 0xff, 0x67, + 0xd7, 0xed, 0x43, 0x43, 0x28, 0x73, 0x74, 0x9d, 0xd7, 0x5f, 0xa3, 0xce, 0xe7, 0x95, 0x98, 0x3a, + 0xb0, 0x7f, 0x6f, 0xc0, 0xfa, 0xfd, 0x67, 0x03, 0x9a, 0x30, 0x8c, 0xfe, 0x27, 0x43, 0xe2, 0x18, + 0x16, 0x49, 0x05, 0x4f, 0x58, 0xb5, 0xed, 0xda, 0x4e, 0x73, 0xef, 0x6d, 0x27, 0x1d, 0x62, 0x4e, + 0x31, 0xdb, 0xb2, 0x41, 0xe6, 0x54, 0xb5, 0x7b, 0xa3, 0xb2, 0xf7, 0xa6, 0x2d, 0xc3, 0xfe, 0xa3, + 0x01, 0x37, 0x55, 0xf8, 0xbb, 0xc4, 0x23, 0xcf, 0x11, 0x0f, 0x0e, 0x49, 0xc4, 0xfa, 0xe2, 0x1b, + 0xdb, 0x69, 0xc3, 0x62, 0xa0, 0x91, 0x7c, 0xc9, 0x7c, 0x14, 0x04, 0xda, 0x4e, 0xcd, 0xa3, 0x88, + 0x67, 0x6c, 0x3f, 0x08, 0xcc, 0x1d, 0x58, 0x29, 0x79, 0xb8, 0xca, 0xa7, 0x0a, 0xb3, 0x62, 0x5b, + 0xca, 0xd9, 0x74, 0x96, 0x89, 0xfd, 0x2f, 0x03, 0x56, 0x3e, 0x0c, 0x59, 0x07, 0x85, 0xa7, 0x21, + 0x12, 0x3d, 0x55, 0x7a, 0x43, 0x95, 0x1e, 0x4e, 0xb2, 0x9e, 0xd7, 0xe6, 0x4d, 0x9c, 0x1e, 0x25, + 0xa6, 0xa7, 0xd0, 0xfb, 0xb0, 0x5a, 0x74, 0x61, 0x51, 0x05, 0xda, 0x9b, 0x83, 0xb5, 0x17, 0x5f, + 0x6d, 0x2d, 0xe7, 0xc5, 0xd6, 0xd6, 0x15, 0x71, 0xe8, 0x2d, 0xe3, 0x11, 0x42, 0x60, 0xb6, 0xa0, + 0x49, 0x3b, 0xd8, 0x17, 0xe4, 0x99, 0x1f, 0x0d, 0xfa, 0xba, 0x80, 0xea, 0x5e, 0x83, 0x76, 0xf0, + 0x29, 0x79, 0xf6, 0x68, 0xd0, 0x37, 0xdf, 0x85, 0x37, 0xf3, 0x05, 0xec, 0x27, 0x28, 0xf4, 0x95, + 0xbc, 0x0a, 0x07, 0xd7, 0xf5, 0xb4, 0xe0, 0xad, 0xe5, 0xa7, 0xe7, 0x28, 0x54, 0xca, 0xf6, 0x83, + 0x80, 0xdb, 0x7f, 0x9b, 0x81, 0xd9, 0x13, 0xc4, 0x51, 0x5f, 0x98, 0x67, 0xb0, 0x2c, 0x49, 0x3f, + 0x0e, 0x91, 0x24, 0x7e, 0x3a, 0xe1, 0x33, 0x4f, 0x6f, 0xeb, 0xc9, 0x5f, 0x5d, 0x96, 0x4e, 0x65, + 0x3d, 0x26, 0xbb, 0x4e, 0x5b, 0x53, 0x4f, 0x25, 0x92, 0xc4, 0x5b, 0xca, 0x31, 0x52, 0xa2, 0x79, + 0x17, 0x2c, 0xc9, 0x07, 0x42, 0x96, 0xb3, 0xb7, 0x1c, 0x3a, 0x69, 0x2e, 0xdf, 0xcc, 0xcf, 0xd3, + 0x71, 0x55, 0x0c, 0x9b, 0xab, 0xc7, 0x6c, 0xed, 0x9b, 0x8c, 0xd9, 0x53, 0x58, 0x53, 0x3b, 0x6a, + 0x1c, 0xb3, 0x3e, 0x39, 0xe6, 0xaa, 0x92, 0x1f, 0x05, 0xfd, 0x18, 0xcc, 0x44, 0xe0, 0x71, 0xcc, + 0x99, 0xd7, 0xb0, 0x33, 0x11, 0x78, 0x14, 0x32, 0x80, 0x4d, 0xa1, 0x8a, 0xcf, 0xef, 0x13, 0xa9, + 0x87, 0x76, 0x1c, 0x92, 0x88, 0x8a, 0x5e, 0x0e, 0x3e, 0x3b, 0x39, 0xf8, 0x86, 0x06, 0xfa, 0x48, + 0xe1, 0x78, 0x39, 0x4c, 0xa6, 0xa5, 0x0d, 0xad, 0xab, 0xb5, 0x14, 0x09, 0x9a, 0xd3, 0x09, 0xfa, + 0xd6, 0x15, 0x10, 0x45, 0x96, 0x04, 0xbc, 0x53, 0x59, 0x2e, 0xaa, 0xab, 0x7d, 0xdd, 0x50, 0x3e, + 0x27, 0x5d, 0x35, 0x81, 0x51, 0xba, 0x67, 0x08, 0x29, 0x16, 0x64, 0x36, 0x3d, 0xd4, 0x15, 0xa8, + 0x98, 0x1c, 0x6d, 0x46, 0xa3, 0xec, 0x16, 0x61, 0x97, 0x3b, 0xa8, 0x98, 0x11, 0x5e, 0x05, 0xeb, + 0x03, 0x42, 0x1e, 0xd6, 0xe7, 0xe7, 0x57, 0x1a, 0xf6, 0xf7, 0xa0, 0xa1, 0x5b, 0x74, 0x1f, 0x5f, + 0x08, 0x73, 0x13, 0x1a, 0xaa, 0xd6, 0x89, 0x10, 0x44, 0x58, 0x86, 0xee, 0xec, 0x92, 0x60, 0x4b, + 0xd8, 0xb8, 0xee, 0x0e, 0x25, 0xcc, 0x27, 0x30, 0x17, 0x13, 0xbd, 0xe0, 0xb5, 0x60, 0x73, 0xef, + 0x3d, 0x67, 0x82, 0x1b, 0xae, 0x73, 0x1d, 0xa0, 0x97, 0xa3, 0xd9, 0xbc, 0xbc, 0xb9, 0x8d, 0xad, + 0x10, 0x61, 0x9e, 0x8f, 0x2b, 0xfd, 0xf1, 0x6b, 0x29, 0x1d, 0xc3, 0x2b, 0x75, 0xde, 0x86, 0xe6, + 0x7e, 0xea, 0xf6, 0x4f, 0xa8, 0x90, 0x97, 0xc3, 0xb2, 0x50, 0x0d, 0xcb, 0x43, 0x58, 0xca, 0xd6, + 0xe1, 0x19, 0xd3, 0x63, 0xc6, 0xfc, 0x36, 0x40, 0xb6, 0x47, 0xd5, 0x78, 0x4a, 0x07, 0x71, 0x23, + 0xa3, 0x1c, 0x05, 0x23, 0x1b, 0x6c, 0x7a, 0x64, 0x83, 0xd9, 0x1e, 0x2c, 0x9f, 0x0b, 0xfc, 0xd3, + 0xfc, 0xae, 0xf4, 0x38, 0x16, 0xe6, 0x1b, 0x30, 0xab, 0x3a, 0x23, 0x03, 0xaa, 0x7b, 0x33, 0x89, + 0xc0, 0x47, 0x7a, 0x16, 0x97, 0xf7, 0x31, 0x16, 0xfb, 0x34, 0x10, 0xd6, 0xf4, 0x76, 0x6d, 0xa7, + 0xee, 0x2d, 0x0d, 0x4a, 0xf1, 0xa3, 0x40, 0xd8, 0x3f, 0x83, 0x66, 0x05, 0xd0, 0x5c, 0x82, 0xe9, + 0x02, 0x6b, 0x9a, 0x06, 0xe6, 0x3d, 0xd8, 0x28, 0x81, 0x46, 0x87, 0x6b, 0x8a, 0xd8, 0xf0, 0x6e, + 0x14, 0x0c, 0x23, 0xf3, 0x55, 0xd8, 0x8f, 0x61, 0xfd, 0xa8, 0x6c, 0xe5, 0x62, 0x74, 0x8f, 0x78, + 0x68, 0x8c, 0xee, 0xe8, 0x4d, 0x68, 0x14, 0xbf, 0x43, 0xb4, 0xf7, 0x75, 0xaf, 0x24, 0xd8, 0x7d, + 0x58, 0x39, 0x17, 0xf8, 0x94, 0x44, 0x41, 0x09, 0x76, 0x4d, 0x00, 0x0e, 0xc6, 0x81, 0x26, 0xbe, + 0xd4, 0x96, 0xea, 0x18, 0x6c, 0x9c, 0xa3, 0x90, 0x06, 0x48, 0x32, 0x7e, 0x4a, 0x64, 0xba, 0x56, + 0x4f, 0x10, 0xbe, 0x20, 0x52, 0x98, 0x1e, 0xd4, 0x43, 0x2a, 0x64, 0x56, 0x59, 0x77, 0xaf, 0xad, + 0xac, 0x64, 0xd7, 0xb9, 0x0e, 0xe4, 0x10, 0x49, 0x94, 0x75, 0xa4, 0xc6, 0xb2, 0xbf, 0x0b, 0x6b, + 0x1f, 0x21, 0x39, 0xe0, 0x24, 0x18, 0xc9, 0xf1, 0x0a, 0xd4, 0x54, 0xfe, 0x0c, 0x9d, 0x3f, 0xf5, + 0xa8, 0xb6, 0xbc, 0x75, 0xff, 0x93, 0x98, 0x71, 0x49, 0x82, 0x4b, 0x11, 0x79, 0x45, 0x78, 0x2f, + 0x60, 0x4d, 0x05, 0x4b, 0x90, 0x28, 0xf0, 0x0b, 0x3f, 0xd3, 0x3c, 0x36, 0xf7, 0x7e, 0x34, 0x51, + 0x77, 0x8c, 0xab, 0xcb, 0x1c, 0x58, 0x4d, 0xc6, 0xe8, 0xc2, 0xfe, 0xad, 0x01, 0xd6, 0x31, 0x19, + 0xee, 0x0b, 0x41, 0xbb, 0x51, 0x9f, 0x44, 0x52, 0x4d, 0x36, 0x84, 0x89, 0x7a, 0x34, 0xdf, 0x82, + 0xc5, 0x62, 0x93, 0xea, 0x05, 0x6a, 0xe8, 0x05, 0xba, 0x90, 0x13, 0x55, 0x83, 0x99, 0xf7, 0x00, + 0x62, 0x4e, 0x12, 0x1f, 0xfb, 0x17, 0x64, 0x98, 0x65, 0x71, 0xb3, 0xba, 0x18, 0xd3, 0x5f, 0x89, + 0xce, 0xc9, 0xa0, 0x13, 0x52, 0x7c, 0x4c, 0x86, 0xde, 0xbc, 0xe2, 0x6f, 0x1f, 0x93, 0xa1, 0xba, + 0xe9, 0xc4, 0xec, 0x39, 0xe1, 0x7a, 0x9b, 0xd5, 0xbc, 0xf4, 0xc5, 0xfe, 0x9d, 0x01, 0x37, 0x8a, + 0x74, 0xe4, 0xe5, 0x7a, 0x32, 0xe8, 0x28, 0x89, 0x57, 0xc4, 0xed, 0x92, 0xb5, 0xd3, 0x57, 0x58, + 0xfb, 0x3e, 0x2c, 0x14, 0x0d, 0xa2, 0xec, 0xad, 0x4d, 0x60, 0x6f, 0x33, 0x97, 0x38, 0x26, 0x43, + 0xfb, 0x97, 0x15, 0xdb, 0x0e, 0x86, 0x95, 0xd9, 0xc7, 0xff, 0x8b, 0x6d, 0x85, 0xda, 0xaa, 0x6d, + 0xb8, 0x2a, 0x7f, 0xc9, 0x81, 0xda, 0x65, 0x07, 0xec, 0x3f, 0x18, 0xb0, 0x5e, 0xd5, 0x2a, 0xce, + 0xd8, 0x09, 0x1f, 0x44, 0xe4, 0x55, 0xda, 0xcb, 0xf6, 0x9b, 0xae, 0xb6, 0xdf, 0x13, 0x58, 0x1a, + 0x31, 0x4a, 0x64, 0xd1, 0xf8, 0xc1, 0x44, 0x35, 0x56, 0x99, 0xae, 0xde, 0x62, 0xd5, 0x0f, 0x61, + 0xff, 0xda, 0x28, 0xd7, 0x4c, 0xba, 0xbd, 0xc4, 0x7e, 0x18, 0x66, 0x57, 0x60, 0x33, 0x86, 0xb9, + 0x74, 0x41, 0x8a, 0xac, 0x2f, 0x37, 0xaf, 0x5c, 0x85, 0x87, 0x04, 0xeb, 0x6d, 0x78, 0x57, 0x95, + 0xee, 0x9f, 0xbf, 0xde, 0xba, 0xdd, 0xa5, 0xb2, 0x37, 0xe8, 0x38, 0x98, 0xf5, 0xdd, 0xec, 0xeb, + 0x41, 0xfa, 0xef, 0x8e, 0x08, 0x2e, 0x5c, 0x39, 0x8c, 0x89, 0xc8, 0x65, 0xc4, 0x9f, 0xfe, 0xf9, + 0xd7, 0xef, 0x1b, 0x5e, 0xae, 0xc6, 0xfe, 0x8d, 0x01, 0x2b, 0x8f, 0x63, 0x49, 0x82, 0xa3, 0xa8, + 0xc8, 0xdd, 0x64, 0xc5, 0x7d, 0x0b, 0x16, 0xf4, 0x8f, 0xb7, 0xfc, 0x13, 0xc0, 0xb4, 0xae, 0xd3, + 0xa6, 0xa6, 0x65, 0x3f, 0xef, 0xaf, 0xac, 0x61, 0xb5, 0x3f, 0x62, 0x5d, 0x40, 0xba, 0xca, 0xd2, + 0x8b, 0x67, 0x23, 0xce, 0x4b, 0xea, 0xe0, 0xc9, 0x17, 0x2f, 0x5a, 0xc6, 0x97, 0x2f, 0x5a, 0xc6, + 0x3f, 0x5e, 0xb4, 0x8c, 0x4f, 0x5f, 0xb6, 0xa6, 0xbe, 0x7c, 0xd9, 0x9a, 0xfa, 0xfb, 0xcb, 0xd6, + 0xd4, 0xcf, 0xdf, 0xbb, 0xec, 0x66, 0x99, 0x8d, 0x3b, 0xc5, 0x17, 0xa4, 0xe4, 0x87, 0xee, 0x27, + 0xa3, 0xdf, 0xa7, 0x74, 0x04, 0x3a, 0xb3, 0x7a, 0x6e, 0xbe, 0xfb, 0x9f, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xc6, 0x15, 0xa0, 0x59, 0xd0, 0x12, 0x00, 0x00, } func (m *ConsumerAdditionProposal) Marshal() (dAtA []byte, err error) { @@ -2686,6 +2766,53 @@ func (m *ConsumerRewardsAllocation) MarshalToSizedBuffer(dAtA []byte) (int, erro return len(dAtA) - i, nil } +func (m *OptedInValidator) 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 *OptedInValidator) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *OptedInValidator) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.PublicKey) > 0 { + i -= len(m.PublicKey) + copy(dAtA[i:], m.PublicKey) + i = encodeVarintProvider(dAtA, i, uint64(len(m.PublicKey))) + i-- + dAtA[i] = 0x22 + } + if m.Power != 0 { + i = encodeVarintProvider(dAtA, i, uint64(m.Power)) + i-- + dAtA[i] = 0x18 + } + if m.BlockHeight != 0 { + i = encodeVarintProvider(dAtA, i, uint64(m.BlockHeight)) + i-- + dAtA[i] = 0x10 + } + if len(m.ProviderAddr) > 0 { + i -= len(m.ProviderAddr) + copy(dAtA[i:], m.ProviderAddr) + i = encodeVarintProvider(dAtA, i, uint64(len(m.ProviderAddr))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + func encodeVarintProvider(dAtA []byte, offset int, v uint64) int { offset -= sovProvider(v) base := offset @@ -3172,6 +3299,29 @@ func (m *ConsumerRewardsAllocation) Size() (n int) { return n } +func (m *OptedInValidator) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ProviderAddr) + if l > 0 { + n += 1 + l + sovProvider(uint64(l)) + } + if m.BlockHeight != 0 { + n += 1 + sovProvider(uint64(m.BlockHeight)) + } + if m.Power != 0 { + n += 1 + sovProvider(uint64(m.Power)) + } + l = len(m.PublicKey) + if l > 0 { + n += 1 + l + sovProvider(uint64(l)) + } + return n +} + func sovProvider(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } @@ -6549,6 +6699,162 @@ func (m *ConsumerRewardsAllocation) Unmarshal(dAtA []byte) error { } return nil } +func (m *OptedInValidator) 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 ErrIntOverflowProvider + } + 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: OptedInValidator: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: OptedInValidator: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProviderAddr", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowProvider + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthProvider + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthProvider + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ProviderAddr = append(m.ProviderAddr[:0], dAtA[iNdEx:postIndex]...) + if m.ProviderAddr == nil { + m.ProviderAddr = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType) + } + m.BlockHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowProvider + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.BlockHeight |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Power", wireType) + } + m.Power = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowProvider + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Power |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PublicKey", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowProvider + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthProvider + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthProvider + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PublicKey = append(m.PublicKey[:0], dAtA[iNdEx:postIndex]...) + if m.PublicKey == nil { + m.PublicKey = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipProvider(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthProvider + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipProvider(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0