diff --git a/api/gateway/apimiddleware/process_field.go b/api/gateway/apimiddleware/process_field.go index d364fdd5c4fe..dcd4f7c038df 100644 --- a/api/gateway/apimiddleware/process_field.go +++ b/api/gateway/apimiddleware/process_field.go @@ -26,6 +26,23 @@ func processField(s interface{}, processors []fieldProcessor) error { t := reflect.TypeOf(s).Elem() v := reflect.Indirect(reflect.ValueOf(s)) + if t.Kind() == reflect.Struct { + err := processStructField(t, v, processors) + return err + } else if t.Kind() == reflect.Slice { + for i := 0; i < v.Len(); i++ { + if err := processField(v.Index(i).Interface(), processors); err != nil { + return errors.Wrapf(err, "could not process field '%s'", t.Name()) + } + } + } else { + return fmt.Errorf("processing fields of kind '%v' is unsupported", t.Kind()) + } + + return nil +} + +func processStructField(t reflect.Type, v reflect.Value, processors []fieldProcessor) error { for i := 0; i < t.NumField(); i++ { switch v.Field(i).Kind() { case reflect.Slice: diff --git a/beacon-chain/blockchain/BUILD.bazel b/beacon-chain/blockchain/BUILD.bazel index fab212e32974..6fc05de955a2 100644 --- a/beacon-chain/blockchain/BUILD.bazel +++ b/beacon-chain/blockchain/BUILD.bazel @@ -61,6 +61,7 @@ go_library( "//beacon-chain/startup:go_default_library", "//beacon-chain/state:go_default_library", "//beacon-chain/state/stategen:go_default_library", + "//beacon-chain/rpc/eth/helpers/lightclient:go_default_library", "//config/features:go_default_library", "//config/fieldparams:go_default_library", "//config/params:go_default_library", @@ -75,6 +76,8 @@ go_library( "//monitoring/tracing:go_default_library", "//proto/engine/v1:go_default_library", "//proto/eth/v1:go_default_library", + "//proto/eth/v2:go_default_library", + "//proto/migration:go_default_library", "//proto/prysm/v1alpha1:go_default_library", "//proto/prysm/v1alpha1/attestation:go_default_library", "//runtime/version:go_default_library", @@ -140,6 +143,7 @@ go_test( "//beacon-chain/p2p:go_default_library", "//beacon-chain/state/state-native:go_default_library", "//beacon-chain/state/stateutil:go_default_library", + "//beacon-chain/rpc/eth/helpers/lightclient:go_default_library", "//config/fieldparams:go_default_library", "//config/params:go_default_library", "//consensus-types/blocks:go_default_library", @@ -196,6 +200,7 @@ go_test( "//beacon-chain/execution/testing:go_default_library", "//beacon-chain/forkchoice/types:go_default_library", "//beacon-chain/p2p:go_default_library", + "//beacon-chain/rpc/eth/helpers/lightclient:go_default_library", "//config/params:go_default_library", "//consensus-types/blocks:go_default_library", "//consensus-types/blocks/testing:go_default_library", diff --git a/beacon-chain/blockchain/chain_info.go b/beacon-chain/blockchain/chain_info.go index 74ebf5c3075c..fc4c54061681 100644 --- a/beacon-chain/blockchain/chain_info.go +++ b/beacon-chain/blockchain/chain_info.go @@ -7,6 +7,7 @@ import ( "github.com/pkg/errors" "github.com/prysmaticlabs/prysm/v4/beacon-chain/core/helpers" + "github.com/prysmaticlabs/prysm/v4/beacon-chain/forkchoice" doublylinkedtree "github.com/prysmaticlabs/prysm/v4/beacon-chain/forkchoice/doubly-linked-tree" forkchoicetypes "github.com/prysmaticlabs/prysm/v4/beacon-chain/forkchoice/types" "github.com/prysmaticlabs/prysm/v4/beacon-chain/state" @@ -333,6 +334,11 @@ func (s *Service) HeadValidatorIndexToPublicKey(_ context.Context, index primiti return v.PublicKey(), nil } +// ForkChoicer returns the forkchoice interface. +func (s *Service) ForkChoicer() forkchoice.ForkChoicer { + return s.cfg.ForkChoiceStore +} + // IsOptimistic returns true if the current head is optimistic. func (s *Service) IsOptimistic(_ context.Context) (bool, error) { if slots.ToEpoch(s.CurrentSlot()) < params.BeaconConfig().BellatrixForkEpoch { diff --git a/beacon-chain/blockchain/process_block.go b/beacon-chain/blockchain/process_block.go index 0e8aa0a10b69..04e4c2727901 100644 --- a/beacon-chain/blockchain/process_block.go +++ b/beacon-chain/blockchain/process_block.go @@ -13,6 +13,7 @@ import ( coreTime "github.com/prysmaticlabs/prysm/v4/beacon-chain/core/time" "github.com/prysmaticlabs/prysm/v4/beacon-chain/core/transition" forkchoicetypes "github.com/prysmaticlabs/prysm/v4/beacon-chain/forkchoice/types" + lightclienthelpers "github.com/prysmaticlabs/prysm/v4/beacon-chain/rpc/eth/helpers/lightclient" "github.com/prysmaticlabs/prysm/v4/beacon-chain/state" "github.com/prysmaticlabs/prysm/v4/config/features" "github.com/prysmaticlabs/prysm/v4/config/params" @@ -22,6 +23,7 @@ import ( "github.com/prysmaticlabs/prysm/v4/crypto/bls" "github.com/prysmaticlabs/prysm/v4/encoding/bytesutil" "github.com/prysmaticlabs/prysm/v4/monitoring/tracing" + ethpbv2 "github.com/prysmaticlabs/prysm/v4/proto/eth/v2" ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1" "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1/attestation" "github.com/prysmaticlabs/prysm/v4/runtime/version" @@ -39,6 +41,97 @@ const depositDeadline = 20 * time.Second // This defines size of the upper bound for initial sync block cache. var initialSyncBlockCacheSize = uint64(2 * params.BeaconConfig().SlotsPerEpoch) +// sendLightClientFinalityUpdate sends a light client finality update notification of to the state feed. +func (s *Service) sendLightClientFinalityUpdate(ctx context.Context, signed interfaces.ReadOnlySignedBeaconBlock, + postState state.BeaconState) (int, error) { + // Determine slots per period + config := params.BeaconConfig() + + // Get attested state + attestedRoot := signed.Block().ParentRoot() + attestedState, err := s.cfg.StateGen.StateByRoot(ctx, attestedRoot) + if err != nil { + return 0, errors.Wrap(err, "could not get attested state") + } + + // Get finalized block + var finalizedBlock interfaces.ReadOnlySignedBeaconBlock + finalizedCheckPoint := attestedState.FinalizedCheckpoint() + if finalizedCheckPoint != nil { + finalizedRoot := bytesutil.ToBytes32(finalizedCheckPoint.Root) + finalizedBlock, err = s.cfg.BeaconDB.Block(ctx, finalizedRoot) + if err != nil { + finalizedBlock = nil + } + } + + update, err := lightclienthelpers.NewLightClientFinalityUpdateFromBeaconState( + ctx, + config, + postState, + signed, + attestedState, + finalizedBlock, + ) + + if err != nil { + return 0, errors.Wrap(err, "could not create light client update") + } + + finalityUpdate := lightclienthelpers.NewLightClientFinalityUpdateFromUpdate(update) + + // Return the result + result := ðpbv2.LightClientFinalityUpdateResponse{ + Version: ethpbv2.Version(signed.Version()), + Data: finalityUpdate, + } + + // Send event + return s.cfg.StateNotifier.StateFeed().Send(&feed.Event{ + Type: statefeed.LightClientFinalityUpdate, + Data: result, + }), nil +} + +// sendLightClientOptimisticUpdate sends a light client optimistic update notification of to the state feed. +func (s *Service) sendLightClientOptimisticUpdate(ctx context.Context, signed interfaces.ReadOnlySignedBeaconBlock, + postState state.BeaconState) (int, error) { + // Determine slots per period + config := params.BeaconConfig() + + // Get attested state + attestedRoot := signed.Block().ParentRoot() + attestedState, err := s.cfg.StateGen.StateByRoot(ctx, attestedRoot) + if err != nil { + return 0, errors.Wrap(err, "could not get attested state") + } + + update, err := lightclienthelpers.NewLightClientOptimisticUpdateFromBeaconState( + ctx, + config, + postState, + signed, + attestedState, + ) + + if err != nil { + return 0, errors.Wrap(err, "could not create light client update") + } + + optimisticUpdate := lightclienthelpers.NewLightClientOptimisticUpdateFromUpdate(update) + + // Return the result + result := ðpbv2.LightClientOptimisticUpdateResponse{ + Version: ethpbv2.Version(signed.Version()), + Data: optimisticUpdate, + } + + return s.cfg.StateNotifier.StateFeed().Send(&feed.Event{ + Type: statefeed.LightClientOptimisticUpdate, + Data: result, + }), nil +} + // postBlockProcess is called when a gossip block is received. This function performs // several duties most importantly informing the engine if head was updated, // saving the new head information to the blockchain package and database and @@ -118,6 +211,16 @@ func (s *Service) postBlockProcess(ctx context.Context, signed interfaces.ReadOn }, }) + if _, err := s.sendLightClientOptimisticUpdate(ctx, signed, postState); err != nil { + log.WithError(err) + } + + // Save finalized check point to db and more. + finalized := s.ForkChoicer().FinalizedCheckpoint() + + // LightClientFinalityUpdate needs super majority + s.tryPublishLightClientFinalityUpdate(ctx, signed, finalized, postState) + defer reportAttestationInclusion(b) if err := s.handleEpochBoundary(ctx, postState, blockRoot[:]); err != nil { return err @@ -126,6 +229,33 @@ func (s *Service) postBlockProcess(ctx context.Context, signed interfaces.ReadOn return nil } +func (s *Service) tryPublishLightClientFinalityUpdate(ctx context.Context, signed interfaces.ReadOnlySignedBeaconBlock, finalized *forkchoicetypes.Checkpoint, postState state.BeaconState) { + if finalized.Epoch <= s.lastPublishedLightClientEpoch { + return + } + + config := params.BeaconConfig() + if finalized.Epoch < config.AltairForkEpoch { + return + } + + syncAggregate, err := signed.Block().Body().SyncAggregate() + if err != nil || syncAggregate == nil { + return + } + + if syncAggregate.SyncCommitteeBits.Count()*3 < config.SyncCommitteeSize*2 { + return + } + + _, err = s.sendLightClientFinalityUpdate(ctx, signed, postState) + if err != nil { + log.WithError(err) + } else { + s.lastPublishedLightClientEpoch = finalized.Epoch + } +} + func getStateVersionAndPayload(st state.BeaconState) (int, interfaces.ExecutionData, error) { if st == nil { return 0, nil, errors.New("nil state") diff --git a/beacon-chain/blockchain/process_block_helpers.go b/beacon-chain/blockchain/process_block_helpers.go index 47c4dfe88e3a..590decda3e1b 100644 --- a/beacon-chain/blockchain/process_block_helpers.go +++ b/beacon-chain/blockchain/process_block_helpers.go @@ -212,7 +212,7 @@ func (s *Service) fillInForkChoiceMissingBlocks(ctx context.Context, blk interfa // inserts finalized deposits into our finalized deposit trie, needs to be // called in the background -func (s *Service) insertFinalizedDeposits(ctx context.Context, fRoot [32]byte) { +func (s *Service) insertFinalizedDeposits(ctx context.Context, fRoot [32]byte) error { ctx, span := trace.StartSpan(ctx, "blockChain.insertFinalizedDeposits") defer span.End() startTime := time.Now() @@ -220,34 +220,32 @@ func (s *Service) insertFinalizedDeposits(ctx context.Context, fRoot [32]byte) { // Update deposit cache. finalizedState, err := s.cfg.StateGen.StateByRoot(ctx, fRoot) if err != nil { - log.WithError(err).Error("could not fetch finalized state") - return + return errors.Wrap(err, "could not fetch finalized state") } // We update the cache up to the last deposit index in the finalized block's state. // We can be confident that these deposits will be included in some block // because the Eth1 follow distance makes such long-range reorgs extremely unlikely. eth1DepositIndex, err := mathutil.Int(finalizedState.Eth1DepositIndex()) if err != nil { - log.WithError(err).Error("could not cast eth1 deposit index") - return + return errors.Wrap(err, "could not cast eth1 deposit index") } // The deposit index in the state is always the index of the next deposit // to be included(rather than the last one to be processed). This was most likely // done as the state cannot represent signed integers. finalizedEth1DepIdx := eth1DepositIndex - 1 if err = s.cfg.DepositCache.InsertFinalizedDeposits(ctx, int64(finalizedEth1DepIdx)); err != nil { - log.WithError(err).Error("could not insert finalized deposits") - return + return errors.Wrap(err, "could not insert finalized deposits") } // Deposit proofs are only used during state transition and can be safely removed to save space. if err = s.cfg.DepositCache.PruneProofs(ctx, int64(finalizedEth1DepIdx)); err != nil { - log.WithError(err).Error("could not prune deposit proofs") + return errors.Wrap(err, "could not prune deposit proofs") } // Prune deposits which have already been finalized, the below method prunes all pending deposits (non-inclusive) up // to the provided eth1 deposit index. s.cfg.DepositCache.PrunePendingDeposits(ctx, int64(eth1DepositIndex)) // lint:ignore uintcast -- Deposit index should not exceed int64 in your lifetime. log.WithField("duration", time.Since(startTime).String()).Debug("Finalized deposit insertion completed") + return nil } // This ensures that the input root defaults to using genesis root instead of zero hashes. This is needed for handling diff --git a/beacon-chain/blockchain/receive_block.go b/beacon-chain/blockchain/receive_block.go index f388c86d7913..dbb43ab54b55 100644 --- a/beacon-chain/blockchain/receive_block.go +++ b/beacon-chain/blockchain/receive_block.go @@ -103,7 +103,9 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig go s.sendNewFinalizedEvent(ctx, blockCopy, postState, finalized) depCtx, cancel := context.WithTimeout(context.Background(), depositDeadline) go func() { - s.insertFinalizedDeposits(depCtx, finalized.Root) + if err := s.insertFinalizedDeposits(depCtx, finalized.Root); err != nil { + log.WithError(err).Error("Could not insert finalized deposits.") + } cancel() }() } diff --git a/beacon-chain/blockchain/service.go b/beacon-chain/blockchain/service.go index cc39c5f49c74..60356022e5f7 100644 --- a/beacon-chain/blockchain/service.go +++ b/beacon-chain/blockchain/service.go @@ -46,22 +46,23 @@ import ( // Service represents a service that handles the internal // logic of managing the full PoS beacon chain. type Service struct { - cfg *config - ctx context.Context - cancel context.CancelFunc - genesisTime time.Time - head *head - headLock sync.RWMutex - originBlockRoot [32]byte // genesis root, or weak subjectivity checkpoint root, depending on how the node is initialized - nextEpochBoundarySlot primitives.Slot - boundaryRoots [][32]byte - checkpointStateCache *cache.CheckpointStateCache - initSyncBlocks map[[32]byte]interfaces.ReadOnlySignedBeaconBlock - initSyncBlocksLock sync.RWMutex - wsVerifier *WeakSubjectivityVerifier - clockSetter startup.ClockSetter - clockWaiter startup.ClockWaiter - syncComplete chan struct{} + cfg *config + ctx context.Context + cancel context.CancelFunc + genesisTime time.Time + head *head + headLock sync.RWMutex + originBlockRoot [32]byte // genesis root, or weak subjectivity checkpoint root, depending on how the node is initialized + nextEpochBoundarySlot primitives.Slot + boundaryRoots [][32]byte + checkpointStateCache *cache.CheckpointStateCache + initSyncBlocks map[[32]byte]interfaces.ReadOnlySignedBeaconBlock + initSyncBlocksLock sync.RWMutex + wsVerifier *WeakSubjectivityVerifier + clockSetter startup.ClockSetter + clockWaiter startup.ClockWaiter + syncComplete chan struct{} + lastPublishedLightClientEpoch primitives.Epoch } // config options for the service. diff --git a/beacon-chain/core/feed/state/events.go b/beacon-chain/core/feed/state/events.go index 1f0af7ac462c..a5c63bada859 100644 --- a/beacon-chain/core/feed/state/events.go +++ b/beacon-chain/core/feed/state/events.go @@ -27,6 +27,10 @@ const ( NewHead // MissedSlot is sent when we need to notify users that a slot was missed. MissedSlot + // LightClientFinalityUpdate event + LightClientFinalityUpdate + // LightClientOptimisticUpdate event + LightClientOptimisticUpdate ) // BlockProcessedData is the data sent with BlockProcessed events. diff --git a/beacon-chain/lightclient/BUILD.bazel b/beacon-chain/lightclient/BUILD.bazel new file mode 100644 index 000000000000..6e6fc65c3d09 --- /dev/null +++ b/beacon-chain/lightclient/BUILD.bazel @@ -0,0 +1,13 @@ +load("@prysm//tools/go:def.bzl", "go_library") + +go_library( + name = "go_default_library", + srcs = [ + "config.go", + "helpers.go", + "store.go", + "update.go", + ], + importpath = "github.com/prysmaticlabs/prysm/v3/beacon-chain/lightclient", + visibility = ["//visibility:public"], +) diff --git a/beacon-chain/lightclient/config.go b/beacon-chain/lightclient/config.go new file mode 100644 index 000000000000..8b17bfdfed26 --- /dev/null +++ b/beacon-chain/lightclient/config.go @@ -0,0 +1,147 @@ +package lightclient + +import ( + "encoding/json" + "strconv" + + "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/prysmaticlabs/prysm/v4/config/params" + types "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" + "github.com/prysmaticlabs/prysm/v4/encoding/bytesutil" +) + +// ConfigJSON is the JSON representation of the light client config. +type ConfigJSON struct { + CapellaForkEpoch string `json:"capella_fork_epoch"` + CapellaForkVersion string `json:"capella_fork_version" hex:"true"` + BellatrixForkEpoch string `json:"bellatrix_fork_epoch"` + BellatrixForkVersion string `json:"bellatrix_fork_version" hex:"true"` + AltairForkEpoch string `json:"altair_fork_epoch"` + AltairForkVersion string `json:"altair_fork_version" hex:"true"` + GenesisForkVersion string `json:"genesis_fork_version" hex:"true"` + MinSyncCommitteeParticipants string `json:"min_sync_committee_participants"` + GenesisSlot string `json:"genesis_slot"` + DomainSyncCommittee string `json:"domain_sync_committee" hex:"true"` + SlotsPerEpoch string `json:"slots_per_epoch"` + EpochsPerSyncCommitteePeriod string `json:"epochs_per_sync_committee_period"` + SecondsPerSlot string `json:"seconds_per_slot"` +} + +// Config is the light client configuration. It consists of the subset of the beacon chain configuration relevant to the +// light client. Unlike the beacon chain configuration it is serializable to JSON, hence it's a separate object. +type Config struct { + CapellaForkEpoch types.Epoch + CapellaForkVersion []byte + BellatrixForkEpoch types.Epoch + BellatrixForkVersion []byte + AltairForkEpoch types.Epoch + AltairForkVersion []byte + GenesisForkVersion []byte + MinSyncCommitteeParticipants uint64 + GenesisSlot types.Slot + DomainSyncCommittee [4]byte + SlotsPerEpoch types.Slot + EpochsPerSyncCommitteePeriod types.Epoch + SecondsPerSlot uint64 +} + +// NewConfig creates a new light client configuration from a beacon chain configuration. +func NewConfig(chainConfig *params.BeaconChainConfig) *Config { + return &Config{ + CapellaForkEpoch: chainConfig.CapellaForkEpoch, + CapellaForkVersion: chainConfig.CapellaForkVersion, + BellatrixForkEpoch: chainConfig.BellatrixForkEpoch, + BellatrixForkVersion: chainConfig.BellatrixForkVersion, + AltairForkEpoch: chainConfig.AltairForkEpoch, + AltairForkVersion: chainConfig.AltairForkVersion, + GenesisForkVersion: chainConfig.GenesisForkVersion, + MinSyncCommitteeParticipants: chainConfig.MinSyncCommitteeParticipants, + GenesisSlot: chainConfig.GenesisSlot, + DomainSyncCommittee: chainConfig.DomainSyncCommittee, + SlotsPerEpoch: chainConfig.SlotsPerEpoch, + EpochsPerSyncCommitteePeriod: chainConfig.EpochsPerSyncCommitteePeriod, + SecondsPerSlot: chainConfig.SecondsPerSlot, + } +} + +func (c *Config) MarshalJSON() ([]byte, error) { + return json.Marshal(&ConfigJSON{ + CapellaForkEpoch: strconv.FormatUint(uint64(c.CapellaForkEpoch), 10), + CapellaForkVersion: hexutil.Encode(c.CapellaForkVersion), + BellatrixForkEpoch: strconv.FormatUint(uint64(c.BellatrixForkEpoch), 10), + BellatrixForkVersion: hexutil.Encode(c.BellatrixForkVersion), + AltairForkEpoch: strconv.FormatUint(uint64(c.AltairForkEpoch), 10), + AltairForkVersion: hexutil.Encode(c.AltairForkVersion), + GenesisForkVersion: hexutil.Encode(c.GenesisForkVersion), + MinSyncCommitteeParticipants: strconv.FormatUint(c.MinSyncCommitteeParticipants, 10), + GenesisSlot: strconv.FormatUint(uint64(c.GenesisSlot), 10), + DomainSyncCommittee: hexutil.Encode(c.DomainSyncCommittee[:]), + SlotsPerEpoch: strconv.FormatUint(uint64(c.SlotsPerEpoch), 10), + EpochsPerSyncCommitteePeriod: strconv.FormatUint(uint64(c.EpochsPerSyncCommitteePeriod), 10), + SecondsPerSlot: strconv.FormatUint(c.SecondsPerSlot, 10), + }) +} + +func (c *Config) UnmarshalJSON(input []byte) error { + var configJSON ConfigJSON + if err := json.Unmarshal(input, &configJSON); err != nil { + return err + } + var config Config + capellaForkEpoch, err := strconv.ParseUint(configJSON.CapellaForkEpoch, 10, 64) + if err != nil { + return err + } + config.CapellaForkEpoch = types.Epoch(capellaForkEpoch) + if config.CapellaForkVersion, err = hexutil.Decode(configJSON.CapellaForkVersion); err != nil { + return err + } + bellatrixForkEpoch, err := strconv.ParseUint(configJSON.BellatrixForkEpoch, 10, 64) + if err != nil { + return err + } + config.BellatrixForkEpoch = types.Epoch(bellatrixForkEpoch) + if config.BellatrixForkVersion, err = hexutil.Decode(configJSON.BellatrixForkVersion); err != nil { + return err + } + altairForkEpoch, err := strconv.ParseUint(configJSON.AltairForkEpoch, 10, 64) + if err != nil { + return err + } + config.AltairForkEpoch = types.Epoch(altairForkEpoch) + if config.AltairForkVersion, err = hexutil.Decode(configJSON.AltairForkVersion); err != nil { + return err + } + if config.GenesisForkVersion, err = hexutil.Decode(configJSON.GenesisForkVersion); err != nil { + return err + } + if config.MinSyncCommitteeParticipants, err = strconv.ParseUint(configJSON.MinSyncCommitteeParticipants, 10, + 64); err != nil { + return err + } + genesisSlot, err := strconv.ParseUint(configJSON.GenesisSlot, 10, 64) + if err != nil { + return err + } + config.GenesisSlot = types.Slot(genesisSlot) + domainSyncCommittee, err := hexutil.Decode(configJSON.DomainSyncCommittee) + if err != nil { + return err + } + config.DomainSyncCommittee = bytesutil.ToBytes4(domainSyncCommittee) + slotsPerEpoch, err := strconv.ParseUint(configJSON.SlotsPerEpoch, 10, 64) + if err != nil { + return err + } + config.SlotsPerEpoch = types.Slot(slotsPerEpoch) + epochsPerSyncCommitteePeriod, err := strconv.ParseUint(configJSON.EpochsPerSyncCommitteePeriod, 10, 64) + if err != nil { + return err + } + config.EpochsPerSyncCommitteePeriod = types.Epoch(epochsPerSyncCommitteePeriod) + if config.SecondsPerSlot, err = strconv.ParseUint(configJSON.SecondsPerSlot, 10, 64); err != nil { + return err + } + *c = config + return nil +} diff --git a/beacon-chain/lightclient/helpers.go b/beacon-chain/lightclient/helpers.go new file mode 100644 index 000000000000..b1573c377652 --- /dev/null +++ b/beacon-chain/lightclient/helpers.go @@ -0,0 +1,20 @@ +package lightclient + +import ( + types "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" +) + +// computeEpochAtSlot implements compute_epoch_at_slot from the spec. +func computeEpochAtSlot(config *Config, slot types.Slot) types.Epoch { + return types.Epoch(slot / config.SlotsPerEpoch) +} + +// computeSyncCommitteePeriod implements compute_sync_committee_period from the spec. +func computeSyncCommitteePeriod(config *Config, epoch types.Epoch) uint64 { + return uint64(epoch / config.EpochsPerSyncCommitteePeriod) +} + +// computeSyncCommitteePeriodAtSlot implements compute_sync_committee_period_at_slot from the spec. +func computeSyncCommitteePeriodAtSlot(config *Config, slot types.Slot) uint64 { + return computeSyncCommitteePeriod(config, computeEpochAtSlot(config, slot)) +} diff --git a/beacon-chain/lightclient/store.go b/beacon-chain/lightclient/store.go new file mode 100644 index 000000000000..754ac76a1784 --- /dev/null +++ b/beacon-chain/lightclient/store.go @@ -0,0 +1,426 @@ +// Package lightclient implements the light client for the Ethereum 2.0 Beacon Chain. +// It is based on the Altair light client spec at this revision: +// https://github.com/ethereum/consensus-specs/tree/208da34ac4e75337baf79adebf036ab595e39f15/specs/altair/light-client +package lightclient + +import ( + "encoding/json" + "errors" + "fmt" + + ethrpc "github.com/prysmaticlabs/prysm/v4/beacon-chain/rpc/apimiddleware" + "github.com/prysmaticlabs/prysm/v4/beacon-chain/rpc/apimiddleware/helpers" + "github.com/prysmaticlabs/prysm/v4/beacon-chain/rpc/eth/helpers/lightclient" + + "github.com/prysmaticlabs/prysm/v4/beacon-chain/core/signing" + types "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" + "github.com/prysmaticlabs/prysm/v4/container/trie" + "github.com/prysmaticlabs/prysm/v4/crypto/bls/blst" + "github.com/prysmaticlabs/prysm/v4/crypto/bls/common" + ethpbv1 "github.com/prysmaticlabs/prysm/v4/proto/eth/v1" + ethpbv2 "github.com/prysmaticlabs/prysm/v4/proto/eth/v2" +) + +const ( + currentSyncCommitteeIndex = uint64(54) +) + +// Store implements LightClientStore from the spec. +type Store struct { + Config *Config `json:"config,omitempty"` + // FinalizedHeader is a header that is finalized + FinalizedHeader *ethpbv1.BeaconBlockHeader `json:"finalized_header,omitempty"` + // CurrentSyncCommittee is the sync committees corresponding to the finalized header + CurrentSyncCommittee *ethpbv2.SyncCommittee `json:"current_sync_committeeu,omitempty"` + // NextSyncCommittee is the next sync committees corresponding to the finalized header + NextSyncCommittee *ethpbv2.SyncCommittee `json:"next_sync_committee,omitempty"` + // BestValidUpdate is the best available header to switch finalized head to if we see nothing else + BestValidUpdate *ethpbv2.LightClientUpdate `json:"best_valid_update,omitempty"` + // OptimisticHeader is the most recent available reasonably-safe header + OptimisticHeader *ethpbv1.BeaconBlockHeader `json:"optimistic_header,omitempty"` + // PreviousMaxActiveParticipants is the previous max number of active participants in a sync committee (used to + // calculate safety threshold) + PreviousMaxActiveParticipants uint64 `json:"previous_max_active_participants,omitempty"` + // CurrentMaxActiveParticipants is the max number of active participants in a sync committee (used to calculate + // safety threshold) + CurrentMaxActiveParticipants uint64 `json:"current_max_active_participants,omitempty"` +} + +// UnmarshalUpdateFromJSON allows to go from a strictly typed JSON update to a generic light client update. It can be used by +// callers to propagate updates of different types over a single endpoint, and receivers to process it as a generic +// update (e.g., by calling Store.ProcessUpdate()). +func UnmarshalUpdateFromJSON(typedUpdate *ethrpc.TypedLightClientUpdateJson) (*ethpbv2.LightClientUpdate, error) { + var update *ethpbv2.LightClientUpdate + switch typedUpdate.TypeName { + case ethrpc.LightClientUpdateTypeName: + var fullUpdate ethrpc.LightClientUpdateJson + err := json.Unmarshal([]byte(typedUpdate.Data), &fullUpdate) + if err != nil { + return nil, err + } + update, err = helpers.NewLightClientUpdateFromJSON(&fullUpdate) + if err != nil { + return nil, err + } + case ethrpc.LightClientFinalityUpdateTypeName: + var finalityUpdate ethrpc.LightClientFinalityUpdateJson + err := json.Unmarshal([]byte(typedUpdate.Data), &finalityUpdate) + if err != nil { + return nil, err + } + update, err = helpers.NewLightClientUpdateFromFinalityUpdateJSON(&finalityUpdate) + if err != nil { + return nil, err + } + case ethrpc.LightClientOptimisticUpdateTypeName: + var optimisticUpdate ethrpc.LightClientOptimisticUpdateJson + err := json.Unmarshal([]byte(typedUpdate.Data), &optimisticUpdate) + if err != nil { + return nil, err + } + update, err = helpers.NewLightClientUpdateFromOptimisticUpdateJSON(&optimisticUpdate) + if err != nil { + return nil, err + } + default: + return nil, fmt.Errorf("unknown update type %q", typedUpdate.TypeName) + } + return update, nil +} + +// getSubtreeIndex implements get_subtree_index from the spec. +func getSubtreeIndex(index uint64) uint64 { + return index % (uint64(1) << ethpbv2.FloorLog2(index-1)) +} + +// NewStore implements initialize_light_client_store from the spec. +func NewStore(config *Config, trustedBlockRoot [32]byte, + bootstrap *ethpbv2.LightClientBootstrap) (*Store, error) { + if config == nil { + return nil, errors.New("light client config cannot be nil") + } + if bootstrap.Header == nil || bootstrap.CurrentSyncCommittee == nil { + return nil, errors.New("malformed bootstrap") + } + bootstrapRoot, err := bootstrap.Header.HashTreeRoot() + if err != nil { + panic(err) + } + if trustedBlockRoot != bootstrapRoot { + return nil, errors.New("trusted block root does not match bootstrap header") + } + root, err := bootstrap.CurrentSyncCommittee.HashTreeRoot() + if err != nil { + return nil, err + } + if !trie.VerifyMerkleProof( + bootstrap.Header.StateRoot, + root[:], + getSubtreeIndex(currentSyncCommitteeIndex), + bootstrap.CurrentSyncCommitteeBranch) { + return nil, errors.New("current sync committee merkle proof is invalid") + } + return &Store{ + Config: config, + FinalizedHeader: bootstrap.Header, + CurrentSyncCommittee: bootstrap.CurrentSyncCommittee, + NextSyncCommittee: nil, + OptimisticHeader: bootstrap.Header, + }, nil +} + +func (s *Store) Clone() *Store { + return &Store{ + Config: s.Config, + FinalizedHeader: s.FinalizedHeader, + CurrentSyncCommittee: s.CurrentSyncCommittee, + NextSyncCommittee: s.NextSyncCommittee, + BestValidUpdate: s.BestValidUpdate, + OptimisticHeader: s.OptimisticHeader, + PreviousMaxActiveParticipants: s.PreviousMaxActiveParticipants, + CurrentMaxActiveParticipants: s.CurrentMaxActiveParticipants, + } +} + +// isNextSyncCommitteeKnown implements is_next_sync_committee_known from the spec. +func (s *Store) isNextSyncCommitteeKnown() bool { + return s.NextSyncCommittee != nil +} + +func max(a, b uint64) uint64 { + if a > b { + return a + } + return b +} + +// getSafetyThreshold implements get_safety_threshold from the spec. +func (s *Store) getSafetyThreshold() uint64 { + return max(s.PreviousMaxActiveParticipants, s.CurrentMaxActiveParticipants) / 2 +} + +// computeForkVersion implements compute_fork_version from the spec. +func (s *Store) computeForkVersion(epoch types.Epoch) []byte { + if epoch >= s.Config.CapellaForkEpoch { + return s.Config.CapellaForkVersion + } + if epoch >= s.Config.BellatrixForkEpoch { + return s.Config.BellatrixForkVersion + } + if epoch >= s.Config.AltairForkEpoch { + return s.Config.AltairForkVersion + } + return s.Config.GenesisForkVersion +} + +// validateWrappedUpdate implements validate_light_client_update from the spec. +func (s *Store) validateWrappedUpdate(update *update, currentSlot types.Slot, genesisValidatorsRoot []byte) error { + // Verify sync committee has sufficient participants + syncAggregate := update.SyncAggregate + if syncAggregate == nil || syncAggregate.SyncCommitteeBits == nil { + return errors.New("sync aggregate in update is invalid") + } + if syncAggregate.SyncCommitteeBits.Count() < s.Config.MinSyncCommitteeParticipants { + return errors.New("sync committee does not have sufficient participants") + } + + if update.AttestedHeader == nil { + return errors.New("attested header in update is not set") + } + // Verify update does not skip a sync committee period + if !(currentSlot >= update.SignatureSlot && + update.SignatureSlot > update.AttestedHeader.Slot && + (update.FinalizedHeader == nil || update.AttestedHeader.Slot >= update.FinalizedHeader.Slot)) { + return errors.New("update skips a sync committee period") + } + storePeriod := computeSyncCommitteePeriodAtSlot(s.Config, s.FinalizedHeader.Slot) + updateSignaturePeriod := computeSyncCommitteePeriodAtSlot(s.Config, update.SignatureSlot) + if s.isNextSyncCommitteeKnown() { + if !(updateSignaturePeriod == storePeriod || updateSignaturePeriod == storePeriod+1) { + return errors.New("update skips a sync committee period") + } + } else { + if updateSignaturePeriod != storePeriod { + return errors.New("update skips a sync committee period") + } + } + + // Verify update is relevant + updateAttestedPeriod := computeSyncCommitteePeriodAtSlot(s.Config, update.AttestedHeader.Slot) + updateHasNextSyncCommittee := !s.isNextSyncCommitteeKnown() && (update.IsSyncCommiteeUpdate() && updateAttestedPeriod == storePeriod) + if !(update.AttestedHeader.Slot > s.FinalizedHeader.Slot || updateHasNextSyncCommittee) { + return errors.New("update is not relevant") + } + + // Verify that the finality branch, if present, confirms finalized header to match the finalized checkpoint root + // saved in the state of attested header. Note that the genesis finalized checkpoint root is represented as a zero + // hash. + if !update.IsFinalityUpdate() { + if update.FinalizedHeader != nil { + return errors.New("finality branch is present but update is not finality") + } + } else { + var finalizedRoot [32]byte + if update.FinalizedHeader.Slot == s.Config.GenesisSlot { + if update.FinalizedHeader.String() != (ðpbv1.BeaconBlockHeader{}).String() { + return errors.New("genesis finalized checkpoint root is not represented as a zero hash") + } + finalizedRoot = [32]byte{} + } else { + var err error + if finalizedRoot, err = update.FinalizedHeader.HashTreeRoot(); err != nil { + return err + } + } + if !trie.VerifyMerkleProof( + update.AttestedHeader.StateRoot, + finalizedRoot[:], + getSubtreeIndex(ethpbv2.FinalizedRootIndex), + update.FinalityBranch) { + return errors.New("finality branch is invalid") + } + } + + // Verify that the next sync committee, if present, actually is the next sync committee saved in the state of the + // attested header + if !update.IsSyncCommiteeUpdate() { + if update.NextSyncCommittee != nil { + return errors.New("sync committee branch is present but update is not sync committee") + } + } else { + if updateAttestedPeriod == storePeriod && s.isNextSyncCommitteeKnown() { + if !update.NextSyncCommittee.Equals(s.NextSyncCommittee) { + return errors.New("next sync committee is not known") + } + } + root, err := update.NextSyncCommittee.HashTreeRoot() + if err != nil { + return err + } + if !trie.VerifyMerkleProof( + update.AttestedHeader.StateRoot, + root[:], + getSubtreeIndex(ethpbv2.NextSyncCommitteeIndex), + update.NextSyncCommitteeBranch) { + return errors.New("sync committee branch is invalid") + } + } + + var syncCommittee *ethpbv2.SyncCommittee + // Verify sync committee aggregate signature + if updateSignaturePeriod == storePeriod { + syncCommittee = s.CurrentSyncCommittee + } else { + syncCommittee = s.NextSyncCommittee + } + var participantPubkeys []common.PublicKey + for i := uint64(0); i < syncAggregate.SyncCommitteeBits.Len(); i++ { + bit := syncAggregate.SyncCommitteeBits.BitAt(i) + if bit { + publicKey, err := blst.PublicKeyFromBytes(syncCommittee.Pubkeys[i]) + if err != nil { + return err + } + participantPubkeys = append(participantPubkeys, publicKey) + } + } + forkVersion := s.computeForkVersion(computeEpochAtSlot(s.Config, update.SignatureSlot)) + domain, err := signing.ComputeDomain(s.Config.DomainSyncCommittee, forkVersion, genesisValidatorsRoot) + if err != nil { + return err + } + signingRoot, err := signing.ComputeSigningRoot(update.AttestedHeader, domain) + if err != nil { + return err + } + signature, err := blst.SignatureFromBytes(syncAggregate.SyncCommitteeSignature) + if err != nil { + return err + } + if !signature.FastAggregateVerify(participantPubkeys, signingRoot) { + return errors.New("sync committee signature is invalid") + } + + return nil +} + +// applyUpdate implements apply_light_client_update from the spec. +func (s *Store) applyUpdate(update *ethpbv2.LightClientUpdate) error { + storePeriod := computeSyncCommitteePeriodAtSlot(s.Config, s.FinalizedHeader.Slot) + updateFinalizedPeriod := computeSyncCommitteePeriodAtSlot(s.Config, update.FinalizedHeader.Slot) + if !s.isNextSyncCommitteeKnown() { + if updateFinalizedPeriod != storePeriod { + return errors.New("update finalized period does not match store period") + } + s.NextSyncCommittee = update.NextSyncCommittee + } else if updateFinalizedPeriod == storePeriod+1 { + s.CurrentSyncCommittee = s.NextSyncCommittee + s.NextSyncCommittee = update.NextSyncCommittee + s.PreviousMaxActiveParticipants = s.CurrentMaxActiveParticipants + s.CurrentMaxActiveParticipants = 0 + } + if update.FinalizedHeader.Slot > s.FinalizedHeader.Slot { + s.FinalizedHeader = update.FinalizedHeader + if s.FinalizedHeader.Slot > s.OptimisticHeader.Slot { + s.OptimisticHeader = s.FinalizedHeader + } + } + return nil +} + +// ProcessForceUpdate implements process_light_client_store_force_update from the spec. +func (s *Store) ProcessForceUpdate(currentSlot types.Slot) error { + if currentSlot > s.FinalizedHeader.Slot+s.Config.SlotsPerEpoch+types.Slot(s.Config.EpochsPerSyncCommitteePeriod) && + s.BestValidUpdate != nil { + // Forced best update when the update timeout has elapsed. + // Because the apply logic waits for `finalized_header.slot` to indicate sync committee finality, + // the `attested_header` may be treated as `finalized_header` in extended periods of non-finality + // to guarantee progression into later sync committee periods according to `is_better_update`. + if s.BestValidUpdate.FinalizedHeader.Slot <= s.FinalizedHeader.Slot { + s.BestValidUpdate.FinalizedHeader = s.BestValidUpdate.AttestedHeader + } + if err := s.applyUpdate(s.BestValidUpdate); err != nil { + return err + } + s.BestValidUpdate = nil + } + return nil +} + +// ValidateUpdate provides a wrapper around validateUpdate() for callers that want to separate validate and apply. +func (s *Store) ValidateUpdate(lightClientUpdate *ethpbv2.LightClientUpdate, + currentSlot types.Slot, genesisValidatorsRoot []byte) error { + update := &update{ + LightClientUpdate: lightClientUpdate, + config: s.Config, + } + return s.validateWrappedUpdate(update, currentSlot, genesisValidatorsRoot) +} + +func (s *Store) maybeValidateAndProcessUpdate(lightClientUpdate *ethpbv2.LightClientUpdate, + currentSlot types.Slot, genesisValidatorsRoot []byte, validated bool) error { + update := &update{ + LightClientUpdate: lightClientUpdate, + config: s.Config, + } + if !validated { + if err := s.validateWrappedUpdate(update, currentSlot, genesisValidatorsRoot); err != nil { + return err + } + } + syncCommiteeBits := update.SyncAggregate.SyncCommitteeBits + + // Update the best update in case we have to force-update to it if the timeout elapses + if s.BestValidUpdate == nil || update.isBetterUpdate(s.BestValidUpdate) { + s.BestValidUpdate = update.LightClientUpdate + } + + // Track the maximum number of active participants in the committee signature + s.CurrentMaxActiveParticipants = max(s.CurrentMaxActiveParticipants, syncCommiteeBits.Count()) + + // Update the optimistic header + if syncCommiteeBits.Count() > s.getSafetyThreshold() && update.AttestedHeader.Slot > s.OptimisticHeader.Slot { + s.OptimisticHeader = update.AttestedHeader + } + + // Update finalized header + updateHasFinalizedNextSyncCommittee := !s.isNextSyncCommitteeKnown() && update.IsSyncCommiteeUpdate() && + update.IsFinalityUpdate() && computeSyncCommitteePeriodAtSlot(s.Config, update.FinalizedHeader. + Slot) == computeSyncCommitteePeriodAtSlot(s.Config, update.AttestedHeader.Slot) + if syncCommiteeBits.Count()*3 >= syncCommiteeBits.Len()*2 && + ((update.FinalizedHeader != nil && update.FinalizedHeader.Slot > s.FinalizedHeader.Slot) || + updateHasFinalizedNextSyncCommittee) { + // Normal update through 2/3 threshold + if err := s.applyUpdate(update.LightClientUpdate); err != nil { + return err + } + s.BestValidUpdate = nil + } + return nil +} + +// ProcessUpdate implements process_light_client_update from the spec. +func (s *Store) ProcessUpdate(lightClientUpdate *ethpbv2.LightClientUpdate, + currentSlot types.Slot, genesisValidatorsRoot []byte) error { + return s.maybeValidateAndProcessUpdate(lightClientUpdate, currentSlot, genesisValidatorsRoot, false) +} + +// ProcessValidatedUpdate processes a pre-validated update. +func (s *Store) ProcessValidatedUpdate(lightClientUpdate *ethpbv2.LightClientUpdate, + currentSlot types.Slot, genesisValidatorsRoot []byte) error { + return s.maybeValidateAndProcessUpdate(lightClientUpdate, currentSlot, genesisValidatorsRoot, true) +} + +// ProcessFinalityUpdate implements process_light_client_finality_update from the spec. +func (s *Store) ProcessFinalityUpdate(update *ethpbv2.LightClientFinalityUpdate, currentSlot types.Slot, + genesisValidatorsRoot []byte) error { + return s.ProcessUpdate(lightclient.NewLightClientUpdateFromFinalityUpdate(update), currentSlot, + genesisValidatorsRoot) +} + +// ProcessOptimisticUpdate implements process_light_client_optimistic_update from the spec. +func (s *Store) ProcessOptimisticUpdate(update *ethpbv2.LightClientOptimisticUpdate, currentSlot types.Slot, + genesisValidatorsRoot []byte) error { + return s.ProcessUpdate(lightclient.NewLightClientUpdateFromOptimisticUpdate(update), currentSlot, + genesisValidatorsRoot) +} diff --git a/beacon-chain/lightclient/update.go b/beacon-chain/lightclient/update.go new file mode 100644 index 000000000000..c71fd5ca848e --- /dev/null +++ b/beacon-chain/lightclient/update.go @@ -0,0 +1,78 @@ +package lightclient + +import ( + ethpbv2 "github.com/prysmaticlabs/prysm/v4/proto/eth/v2" +) + +// update is a convenience wrapper for a LightClientUpdate to feed config parameters into misc utils. +type update struct { + config *Config + *ethpbv2.LightClientUpdate +} + +// hasRelevantSyncCommittee implements has_relevant_sync_committee from the spec. +func (u *update) hasRelevantSyncCommittee() bool { + return u.IsSyncCommiteeUpdate() && + computeSyncCommitteePeriodAtSlot(u.config, u.AttestedHeader.Slot) == + computeSyncCommitteePeriodAtSlot(u.config, u.SignatureSlot) +} + +// hasSyncCommitteeFinality implements has_sync_committee_finality from the spec. +func (u *update) hasSyncCommitteeFinality() bool { + return computeSyncCommitteePeriodAtSlot(u.config, u.FinalizedHeader.Slot) == + computeSyncCommitteePeriodAtSlot(u.config, u.AttestedHeader.Slot) +} + +// isBetterUpdate implements is_better_update from the spec. +func (u *update) isBetterUpdate(newUpdatePb *ethpbv2.LightClientUpdate) bool { + newUpdate := &update{ + config: u.config, + LightClientUpdate: newUpdatePb, + } + // Compare supermajority (> 2/3) sync committee participation + maxActiveParticipants := newUpdate.SyncAggregate.SyncCommitteeBits.Len() + newNumActiveParticipants := newUpdate.SyncAggregate.SyncCommitteeBits.Count() + oldNumActiveParticipants := u.SyncAggregate.SyncCommitteeBits.Count() + newHasSupermajority := newNumActiveParticipants*3 >= maxActiveParticipants*2 + oldHasSupermajority := oldNumActiveParticipants*3 >= maxActiveParticipants*2 + if newHasSupermajority != oldHasSupermajority { + return newHasSupermajority && !oldHasSupermajority + } + if !newHasSupermajority && newNumActiveParticipants != oldNumActiveParticipants { + return newNumActiveParticipants > oldNumActiveParticipants + } + + // Compare presence of relevant sync committee + newHasRelevantSyncCommittee := newUpdate.hasRelevantSyncCommittee() + oldHasRelevantSyncCommittee := u.hasRelevantSyncCommittee() + if newHasRelevantSyncCommittee != oldHasRelevantSyncCommittee { + return newHasRelevantSyncCommittee + } + + // Compare indication of any finality + newHasFinality := newUpdate.IsFinalityUpdate() + oldHasFinality := u.IsFinalityUpdate() + if newHasFinality != oldHasFinality { + return newHasFinality + } + + // Compare sync committee finality + if newHasFinality { + newHasSyncCommitteeFinality := newUpdate.hasSyncCommitteeFinality() + oldHasSyncCommitteeFinality := u.hasSyncCommitteeFinality() + if newHasSyncCommitteeFinality != oldHasSyncCommitteeFinality { + return newHasSyncCommitteeFinality + } + } + + // Tiebreaker 1: Sync committee participation beyond supermajority + if newNumActiveParticipants != oldNumActiveParticipants { + return newNumActiveParticipants > oldNumActiveParticipants + } + + // Tiebreaker 2: Prefer older data (fewer changes to best) + if newUpdate.AttestedHeader.Slot != u.AttestedHeader.Slot { + return newUpdate.AttestedHeader.Slot < u.AttestedHeader.Slot + } + return newUpdate.SignatureSlot < u.SignatureSlot +} diff --git a/beacon-chain/p2p/service.go b/beacon-chain/p2p/service.go index 8a883b028506..08d49f38149c 100644 --- a/beacon-chain/p2p/service.go +++ b/beacon-chain/p2p/service.go @@ -290,7 +290,7 @@ func (s *Service) Started() bool { } // Encoding returns the configured networking encoding. -func (_ *Service) Encoding() encoder.NetworkEncoding { +func (*Service) Encoding() encoder.NetworkEncoding { return &encoder.SszNetworkEncoder{} } diff --git a/beacon-chain/p2p/testing/mock_host.go b/beacon-chain/p2p/testing/mock_host.go index 38d66533f3cc..63107b7af4f0 100644 --- a/beacon-chain/p2p/testing/mock_host.go +++ b/beacon-chain/p2p/testing/mock_host.go @@ -18,12 +18,12 @@ type MockHost struct { } // ID -- -func (_ *MockHost) ID() peer.ID { +func (*MockHost) ID() peer.ID { return "" } // Peerstore -- -func (_ *MockHost) Peerstore() peerstore.Peerstore { +func (*MockHost) Peerstore() peerstore.Peerstore { return nil } @@ -33,46 +33,46 @@ func (m *MockHost) Addrs() []ma.Multiaddr { } // Network -- -func (_ *MockHost) Network() network.Network { +func (*MockHost) Network() network.Network { return nil } // Mux -- -func (_ *MockHost) Mux() protocol.Switch { +func (*MockHost) Mux() protocol.Switch { return nil } // Connect -- -func (_ *MockHost) Connect(_ context.Context, _ peer.AddrInfo) error { +func (*MockHost) Connect(_ context.Context, _ peer.AddrInfo) error { return nil } // SetStreamHandler -- -func (_ *MockHost) SetStreamHandler(_ protocol.ID, _ network.StreamHandler) {} +func (*MockHost) SetStreamHandler(_ protocol.ID, _ network.StreamHandler) {} // SetStreamHandlerMatch -- func (_ *MockHost) SetStreamHandlerMatch(protocol.ID, func(id protocol.ID) bool, network.StreamHandler) { } // RemoveStreamHandler -- -func (_ *MockHost) RemoveStreamHandler(_ protocol.ID) {} +func (*MockHost) RemoveStreamHandler(_ protocol.ID) {} // NewStream -- -func (_ *MockHost) NewStream(_ context.Context, _ peer.ID, _ ...protocol.ID) (network.Stream, error) { +func (*MockHost) NewStream(_ context.Context, _ peer.ID, _ ...protocol.ID) (network.Stream, error) { return nil, nil } // Close -- -func (_ *MockHost) Close() error { +func (*MockHost) Close() error { return nil } // ConnManager -- -func (_ *MockHost) ConnManager() connmgr.ConnManager { +func (*MockHost) ConnManager() connmgr.ConnManager { return nil } // EventBus -- -func (_ *MockHost) EventBus() event.Bus { +func (*MockHost) EventBus() event.Bus { return nil } diff --git a/beacon-chain/rpc/apimiddleware/custom_handlers.go b/beacon-chain/rpc/apimiddleware/custom_handlers.go index 57293a50cbd6..471e5b52d1ed 100644 --- a/beacon-chain/rpc/apimiddleware/custom_handlers.go +++ b/beacon-chain/rpc/apimiddleware/custom_handlers.go @@ -431,6 +431,10 @@ func receiveEvents(eventChan <-chan *sse.Event, w http.ResponseWriter, req *http default: return apimiddleware.InternalServerError(errors.New("payload version unsupported")) } + case events.LightClientFinalityUpdateTopic: + data = &LightClientFinalityUpdateResponseJson{} + case events.LightClientOptimisticUpdateTopic: + data = &LightClientOptimisticUpdateResponseJson{} case "error": data = &EventErrorJson{} default: diff --git a/beacon-chain/rpc/apimiddleware/custom_hooks.go b/beacon-chain/rpc/apimiddleware/custom_hooks.go index 8bdbd470d783..8f1ae7cbed36 100644 --- a/beacon-chain/rpc/apimiddleware/custom_hooks.go +++ b/beacon-chain/rpc/apimiddleware/custom_hooks.go @@ -279,11 +279,11 @@ func setInitialPublishBlockPostRequest(endpoint *apimiddleware.Endpoint, _ http.ResponseWriter, req *http.Request, ) (apimiddleware.RunDefault, apimiddleware.ErrorJson) { - s := struct { + var s struct { Message struct { Slot string } - }{} + } buf, err := io.ReadAll(req.Body) if err != nil { @@ -363,11 +363,11 @@ func setInitialPublishBlindedBlockPostRequest(endpoint *apimiddleware.Endpoint, _ http.ResponseWriter, req *http.Request, ) (apimiddleware.RunDefault, apimiddleware.ErrorJson) { - s := struct { + var s struct { Message struct { Slot string } - }{} + } buf, err := io.ReadAll(req.Body) if err != nil { @@ -451,6 +451,28 @@ type tempSyncSubcommitteeValidatorsJson struct { Validators []string `json:"validators"` } +type tempLightClientUpdatesByRangeJson struct { + Updates []*LightClientUpdateResponseJson `json:"updates"` +} + +// https://ethereum.github.io/beacon-APIs/?urls.primaryName=dev#/Beacon/getLightClientUpdatesByRange +// grpc-gateway returns a struct with slice embedded, but spec says it should be a list directly instead of a struct. +func prepareLightClientUpdates(body []byte, responseContainer interface{}) (apimiddleware.RunDefault, apimiddleware.ErrorJson) { + var grpcResponse tempLightClientUpdatesByRangeJson + if err := json.Unmarshal(body, &grpcResponse); err != nil { + return false, apimiddleware.InternalServerErrorWithMessage(err, "could not unmarshal response into temp container") + } + + container, ok := responseContainer.(*[]*LightClientUpdateResponseJson) + if !ok { + return false, apimiddleware.InternalServerError(errors.New("container is not of the correct type")) + } + + *container = append(*container, grpcResponse.Updates...) + + return false, nil +} + // https://ethereum.github.io/beacon-APIs/?urls.primaryName=v2.0.0#/Beacon/getEpochSyncCommittees returns validator_aggregates as a nested array. // grpc-gateway returns a struct with nested fields which we have to transform into a plain 2D array. func prepareValidatorAggregates(body []byte, responseContainer interface{}) (apimiddleware.RunDefault, apimiddleware.ErrorJson) { diff --git a/beacon-chain/rpc/apimiddleware/endpoint_factory.go b/beacon-chain/rpc/apimiddleware/endpoint_factory.go index becf529af650..b94547ee1a83 100644 --- a/beacon-chain/rpc/apimiddleware/endpoint_factory.go +++ b/beacon-chain/rpc/apimiddleware/endpoint_factory.go @@ -14,7 +14,7 @@ func (f *BeaconEndpointFactory) IsNil() bool { } // Paths is a collection of all valid beacon chain API paths. -func (_ *BeaconEndpointFactory) Paths() []string { +func (*BeaconEndpointFactory) Paths() []string { return []string{ "/eth/v1/beacon/genesis", "/eth/v1/beacon/states/{state_id}/root", @@ -43,6 +43,10 @@ func (_ *BeaconEndpointFactory) Paths() []string { "/eth/v1/beacon/pool/sync_committees", "/eth/v1/beacon/pool/bls_to_execution_changes", "/eth/v1/beacon/weak_subjectivity", + "/eth/v1/beacon/light_client/bootstrap/{block_root}", + "/eth/v1/beacon/light_client/updates", + "/eth/v1/beacon/light_client/finality_update", + "/eth/v1/beacon/light_client/optimistic_update", "/eth/v1/node/identity", "/eth/v1/node/peers", "/eth/v1/node/peers/{peer_id}", @@ -79,7 +83,7 @@ func (_ *BeaconEndpointFactory) Paths() []string { } // Create returns a new endpoint for the provided API path. -func (_ *BeaconEndpointFactory) Create(path string) (*apimiddleware.Endpoint, error) { +func (*BeaconEndpointFactory) Create(path string) (*apimiddleware.Endpoint, error) { endpoint := apimiddleware.DefaultEndpoint() switch path { case "/eth/v1/beacon/genesis": @@ -178,6 +182,17 @@ func (_ *BeaconEndpointFactory) Create(path string) (*apimiddleware.Endpoint, er } case "/eth/v1/beacon/weak_subjectivity": endpoint.GetResponse = &WeakSubjectivityResponse{} + case "/eth/v1/beacon/light_client/bootstrap/{block_root}": + endpoint.GetResponse = &LightClientBootstrapResponseJson{} + case "/eth/v1/beacon/light_client/updates": + endpoint.GetResponse = &[]*LightClientUpdateResponseJson{} + endpoint.Hooks = apimiddleware.HookCollection{ + OnPreDeserializeGrpcResponseBodyIntoContainer: prepareLightClientUpdates, + } + case "/eth/v1/beacon/light_client/finality_update": + endpoint.GetResponse = &LightClientFinalityUpdateResponseJson{} + case "/eth/v1/beacon/light_client/optimistic_update": + endpoint.GetResponse = &LightClientOptimisticUpdateResponseJson{} case "/eth/v1/node/identity": endpoint.GetResponse = &IdentityResponseJson{} case "/eth/v1/node/peers": diff --git a/beacon-chain/rpc/apimiddleware/helpers/lightclient.go b/beacon-chain/rpc/apimiddleware/helpers/lightclient.go new file mode 100644 index 000000000000..86dfdfe31996 --- /dev/null +++ b/beacon-chain/rpc/apimiddleware/helpers/lightclient.go @@ -0,0 +1,378 @@ +package helpers + +import ( + "errors" + "math/big" + "strconv" + "time" + + "github.com/ethereum/go-ethereum/common/hexutil" + "google.golang.org/protobuf/types/known/timestamppb" + + ethrpc "github.com/prysmaticlabs/prysm/v4/beacon-chain/rpc/apimiddleware" + v11 "github.com/prysmaticlabs/prysm/v4/proto/engine/v1" + + types "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" + ethpbv1 "github.com/prysmaticlabs/prysm/v4/proto/eth/v1" + ethpbv2 "github.com/prysmaticlabs/prysm/v4/proto/eth/v2" +) + +func bytesFromBigInt(numStr string) ([]byte, error) { + num, err := strconv.ParseUint(numStr, 10, 64) + if err != nil { + return nil, err + } + return big.NewInt(0).SetUint64(num).Bytes(), nil +} + +func NewExecutionPayloadHeaderFromJSON(headerJSON *ethrpc.ExecutionPayloadHeaderJson) (*v11.ExecutionPayloadHeader, + error) { + header := &v11.ExecutionPayloadHeader{} + var err error + if header.ParentHash, err = hexutil.Decode(headerJSON.ParentHash); err != nil { + return nil, err + } + if header.FeeRecipient, err = hexutil.Decode(headerJSON.FeeRecipient); err != nil { + return nil, err + } + if header.StateRoot, err = hexutil.Decode(headerJSON.StateRoot); err != nil { + return nil, err + } + if header.ReceiptsRoot, err = hexutil.Decode(headerJSON.ReceiptsRoot); err != nil { + return nil, err + } + if header.LogsBloom, err = hexutil.Decode(headerJSON.LogsBloom); err != nil { + return nil, err + } + if header.PrevRandao, err = hexutil.Decode(headerJSON.PrevRandao); err != nil { + return nil, err + } + if header.BlockNumber, err = strconv.ParseUint(headerJSON.BlockNumber, 10, 64); err != nil { + return nil, err + } + if header.GasLimit, err = strconv.ParseUint(headerJSON.GasLimit, 10, 64); err != nil { + return nil, err + } + if header.GasUsed, err = strconv.ParseUint(headerJSON.GasUsed, 10, 64); err != nil { + return nil, err + } + if header.Timestamp, err = strconv.ParseUint(headerJSON.TimeStamp, 10, 64); err != nil { + return nil, err + } + if header.ExtraData, err = hexutil.Decode(headerJSON.ExtraData); err != nil { + return nil, err + } + + if header.BaseFeePerGas, err = bytesFromBigInt(headerJSON.BaseFeePerGas); err != nil { + return nil, err + } + if len(header.BaseFeePerGas) > 32 { + return nil, errors.New("base fee per gas is too long") + } else if len(header.BaseFeePerGas) < 32 { + padded := make([]byte, 32-len(header.BaseFeePerGas)) + header.BaseFeePerGas = append(padded, header.BaseFeePerGas...) + } + for i := 0; i < len(header.BaseFeePerGas)/2; i++ { + header.BaseFeePerGas[i], header.BaseFeePerGas[len(header.BaseFeePerGas)-1-i] = + header.BaseFeePerGas[len(header.BaseFeePerGas)-1-i], header.BaseFeePerGas[i] + } + + if header.BlockHash, err = hexutil.Decode(headerJSON.BlockHash); err != nil { + return nil, err + } + if header.TransactionsRoot, err = hexutil.Decode(headerJSON.TransactionsRoot); err != nil { + return nil, err + } + return header, nil +} + +func NewExecutionPayloadHeaderCapellaFromJSON(headerJSON *ethrpc.ExecutionPayloadHeaderCapellaJson) (*v11.ExecutionPayloadHeaderCapella, + error) { + header := &v11.ExecutionPayloadHeaderCapella{} + var err error + if header.ParentHash, err = hexutil.Decode(headerJSON.ParentHash); err != nil { + return nil, err + } + if header.FeeRecipient, err = hexutil.Decode(headerJSON.FeeRecipient); err != nil { + return nil, err + } + if header.StateRoot, err = hexutil.Decode(headerJSON.StateRoot); err != nil { + return nil, err + } + if header.ReceiptsRoot, err = hexutil.Decode(headerJSON.ReceiptsRoot); err != nil { + return nil, err + } + if header.LogsBloom, err = hexutil.Decode(headerJSON.LogsBloom); err != nil { + return nil, err + } + if header.PrevRandao, err = hexutil.Decode(headerJSON.PrevRandao); err != nil { + return nil, err + } + if header.BlockNumber, err = strconv.ParseUint(headerJSON.BlockNumber, 10, 64); err != nil { + return nil, err + } + if header.GasLimit, err = strconv.ParseUint(headerJSON.GasLimit, 10, 64); err != nil { + return nil, err + } + if header.GasUsed, err = strconv.ParseUint(headerJSON.GasUsed, 10, 64); err != nil { + return nil, err + } + if header.Timestamp, err = strconv.ParseUint(headerJSON.TimeStamp, 10, 64); err != nil { + return nil, err + } + if header.ExtraData, err = hexutil.Decode(headerJSON.ExtraData); err != nil { + return nil, err + } + + if header.BaseFeePerGas, err = bytesFromBigInt(headerJSON.BaseFeePerGas); err != nil { + return nil, err + } + if len(header.BaseFeePerGas) > 32 { + return nil, errors.New("base fee per gas is too long") + } else if len(header.BaseFeePerGas) < 32 { + padded := make([]byte, 32-len(header.BaseFeePerGas)) + header.BaseFeePerGas = append(padded, header.BaseFeePerGas...) + } + for i := 0; i < len(header.BaseFeePerGas)/2; i++ { + header.BaseFeePerGas[i], header.BaseFeePerGas[len(header.BaseFeePerGas)-1-i] = + header.BaseFeePerGas[len(header.BaseFeePerGas)-1-i], header.BaseFeePerGas[i] + } + + if header.BlockHash, err = hexutil.Decode(headerJSON.BlockHash); err != nil { + return nil, err + } + if header.TransactionsRoot, err = hexutil.Decode(headerJSON.TransactionsRoot); err != nil { + return nil, err + } + if header.WithdrawalsRoot, err = hexutil.Decode(headerJSON.WithdrawalsRoot); err != nil { + return nil, err + } + return header, nil +} + +func NewSyncAggregateFromJSON(syncAggregateJSON *ethrpc.SyncAggregateJson) (*ethpbv1.SyncAggregate, error) { + syncAggregate := ðpbv1.SyncAggregate{} + var err error + if syncAggregate.SyncCommitteeBits, err = hexutil.Decode(syncAggregateJSON.SyncCommitteeBits); err != nil { + return nil, err + } + if syncAggregate.SyncCommitteeSignature, err = hexutil.Decode(syncAggregateJSON.SyncCommitteeSignature); err != nil { + return nil, err + } + return syncAggregate, nil +} + +func timeFromJSON(timestamp string) (*time.Time, error) { + timeInt, err := strconv.ParseInt(timestamp, 10, 64) + if err != nil { + return nil, err + } + t := time.Unix(timeInt, 0) + return &t, nil +} + +func NewGenesisResponse_GenesisFromJSON(genesisJSON *ethrpc.GenesisResponse_GenesisJson) ( + *ethpbv1.GenesisResponse_Genesis, error) { + genesis := ðpbv1.GenesisResponse_Genesis{} + genesisTime, err := timeFromJSON(genesisJSON.GenesisTime) + if err != nil { + return nil, err + } + genesis.GenesisTime = timestamppb.New(*genesisTime) + if genesis.GenesisValidatorsRoot, err = hexutil.Decode(genesisJSON.GenesisValidatorsRoot); err != nil { + return nil, err + } + if genesis.GenesisForkVersion, err = hexutil.Decode(genesisJSON.GenesisForkVersion); err != nil { + return nil, err + } + return genesis, nil +} + +func headerFromJSON(headerJSON *ethrpc.BeaconBlockHeaderJson) (*ethpbv1.BeaconBlockHeader, error) { + if headerJSON == nil { + return nil, nil + } + header := ðpbv1.BeaconBlockHeader{} + var err error + slot, err := strconv.ParseUint(headerJSON.Slot, 10, 64) + if err != nil { + return nil, err + } + header.Slot = types.Slot(slot) + proposerIndex, err := strconv.ParseUint(headerJSON.ProposerIndex, 10, 64) + if err != nil { + return nil, err + } + header.ProposerIndex = types.ValidatorIndex(proposerIndex) + if header.ParentRoot, err = hexutil.Decode(headerJSON.ParentRoot); err != nil { + return nil, err + } + if header.StateRoot, err = hexutil.Decode(headerJSON.StateRoot); err != nil { + return nil, err + } + if header.BodyRoot, err = hexutil.Decode(headerJSON.BodyRoot); err != nil { + return nil, err + } + return header, nil +} + +func syncCommitteeFromJSON(syncCommitteeJSON *ethrpc.SyncCommitteeJson) (*ethpbv2.SyncCommittee, error) { + if syncCommitteeJSON == nil { + return nil, nil + } + syncCommittee := ðpbv2.SyncCommittee{ + Pubkeys: make([][]byte, len(syncCommitteeJSON.Pubkeys)), + } + for i, pubKey := range syncCommitteeJSON.Pubkeys { + var err error + if syncCommittee.Pubkeys[i], err = hexutil.Decode(pubKey); err != nil { + return nil, err + } + } + var err error + if syncCommittee.AggregatePubkey, err = hexutil.Decode(syncCommitteeJSON.AggregatePubkey); err != nil { + return nil, err + } + return syncCommittee, nil +} + +func branchFromJSON(branch []string) ([][]byte, error) { + var branchBytes [][]byte + for _, root := range branch { + branch, err := hexutil.Decode(root) + if err != nil { + return nil, err + } + branchBytes = append(branchBytes, branch) + } + return branchBytes, nil +} + +func NewLightClientBootstrapFromJSON(bootstrapJSON *ethrpc.LightClientBootstrapJson) (*ethpbv2.LightClientBootstrap, + error) { + bootstrap := ðpbv2.LightClientBootstrap{} + var err error + if bootstrap.Header, err = headerFromJSON(bootstrapJSON.Header); err != nil { + return nil, err + } + if bootstrap.CurrentSyncCommittee, err = syncCommitteeFromJSON(bootstrapJSON.CurrentSyncCommittee); err != nil { + return nil, err + } + if bootstrap.CurrentSyncCommitteeBranch, err = branchFromJSON(bootstrapJSON.CurrentSyncCommitteeBranch); err != nil { + return nil, err + } + return bootstrap, nil +} + +func NewLightClientUpdateFromJSON(updateJSON *ethrpc.LightClientUpdateJson) (*ethpbv2.LightClientUpdate, error) { + update := ðpbv2.LightClientUpdate{} + var err error + if update.AttestedHeader, err = headerFromJSON(updateJSON.AttestedHeader); err != nil { + return nil, err + } + if update.NextSyncCommittee, err = syncCommitteeFromJSON(updateJSON.NextSyncCommittee); err != nil { + return nil, err + } + if update.NextSyncCommitteeBranch, err = branchFromJSON(updateJSON.NextSyncCommitteeBranch); err != nil { + return nil, err + } + if update.FinalizedHeader, err = headerFromJSON(updateJSON.FinalizedHeader); err != nil { + return nil, err + } + if update.FinalityBranch, err = branchFromJSON(updateJSON.FinalityBranch); err != nil { + return nil, err + } + if update.SyncAggregate, err = NewSyncAggregateFromJSON(updateJSON.SyncAggregate); err != nil { + return nil, err + } + signatureSlot, err := strconv.ParseUint(updateJSON.SignatureSlot, 10, 64) + if err != nil { + return nil, err + } + update.SignatureSlot = types.Slot(signatureSlot) + return update, nil +} + +func NewLightClientUpdateFromFinalityUpdateJSON(updateJSON *ethrpc.LightClientFinalityUpdateJson) (*ethpbv2. + LightClientUpdate, error) { + update := ðpbv2.LightClientUpdate{} + var err error + if update.AttestedHeader, err = headerFromJSON(updateJSON.AttestedHeader); err != nil { + return nil, err + } + if update.FinalizedHeader, err = headerFromJSON(updateJSON.FinalizedHeader); err != nil { + return nil, err + } + if update.FinalityBranch, err = branchFromJSON(updateJSON.FinalityBranch); err != nil { + return nil, err + } + if update.SyncAggregate, err = NewSyncAggregateFromJSON(updateJSON.SyncAggregate); err != nil { + return nil, err + } + signatureSlot, err := strconv.ParseUint(updateJSON.SignatureSlot, 10, 64) + if err != nil { + return nil, err + } + update.SignatureSlot = types.Slot(signatureSlot) + return update, nil +} + +func NewLightClientUpdateFromOptimisticUpdateJSON(updateJSON *ethrpc.LightClientOptimisticUpdateJson) (*ethpbv2. + LightClientUpdate, error) { + update := ðpbv2.LightClientUpdate{} + var err error + if update.AttestedHeader, err = headerFromJSON(updateJSON.AttestedHeader); err != nil { + return nil, err + } + if update.SyncAggregate, err = NewSyncAggregateFromJSON(updateJSON.SyncAggregate); err != nil { + return nil, err + } + signatureSlot, err := strconv.ParseUint(updateJSON.SignatureSlot, 10, 64) + if err != nil { + return nil, err + } + update.SignatureSlot = types.Slot(signatureSlot) + return update, nil +} + +func NewLightClientFinalityUpdateFromJSON(updateJSON *ethrpc.LightClientFinalityUpdateJson) (*ethpbv2. + LightClientFinalityUpdate, error) { + update := ðpbv2.LightClientFinalityUpdate{} + var err error + if update.AttestedHeader, err = headerFromJSON(updateJSON.AttestedHeader); err != nil { + return nil, err + } + if update.FinalizedHeader, err = headerFromJSON(updateJSON.FinalizedHeader); err != nil { + return nil, err + } + if update.FinalityBranch, err = branchFromJSON(updateJSON.FinalityBranch); err != nil { + return nil, err + } + if update.SyncAggregate, err = NewSyncAggregateFromJSON(updateJSON.SyncAggregate); err != nil { + return nil, err + } + signatureSlot, err := strconv.ParseUint(updateJSON.SignatureSlot, 10, 64) + if err != nil { + return nil, err + } + update.SignatureSlot = types.Slot(signatureSlot) + return update, nil +} + +func NewLightClientOptimisticUpdateFromJSON(updateJSON *ethrpc.LightClientOptimisticUpdateJson) (*ethpbv2.LightClientOptimisticUpdate, + error) { + update := ðpbv2.LightClientOptimisticUpdate{} + var err error + if update.AttestedHeader, err = headerFromJSON(updateJSON.AttestedHeader); err != nil { + return nil, err + } + if update.SyncAggregate, err = NewSyncAggregateFromJSON(updateJSON.SyncAggregate); err != nil { + return nil, err + } + signatureSlot, err := strconv.ParseUint(updateJSON.SignatureSlot, 10, 64) + if err != nil { + return nil, err + } + update.SignatureSlot = types.Slot(signatureSlot) + return update, nil +} diff --git a/beacon-chain/rpc/apimiddleware/structs.go b/beacon-chain/rpc/apimiddleware/structs.go index 1d682c76ce52..0b3da129d270 100644 --- a/beacon-chain/rpc/apimiddleware/structs.go +++ b/beacon-chain/rpc/apimiddleware/structs.go @@ -8,9 +8,9 @@ import ( ethpbv2 "github.com/prysmaticlabs/prysm/v4/proto/eth/v2" ) -//---------------- +// ---------------- // Requests and responses. -//---------------- +// ---------------- type GenesisResponseJson struct { Data *GenesisResponse_GenesisJson `json:"data"` @@ -101,6 +101,56 @@ type RandaoResponseJson struct { Finalized bool `json:"finalized"` } +type LightClientBootstrapResponseJson struct { + Version string `json:"version" enum:"true"` + Data *LightClientBootstrapJson `json:"data"` +} + +type LightClientBootstrapJson struct { + Header *BeaconBlockHeaderJson `json:"header"` + CurrentSyncCommittee *SyncCommitteeJson `json:"current_sync_committee"` + CurrentSyncCommitteeBranch []string `json:"current_sync_committee_branch" hex:"true"` +} + +type LightClientUpdateResponseJson struct { + Version string `json:"version" enum:"true"` + Data *LightClientUpdateJson `json:"data"` +} + +type LightClientUpdateJson struct { + AttestedHeader *BeaconBlockHeaderJson `json:"attested_header"` + NextSyncCommittee *SyncCommitteeJson `json:"next_sync_committee,omitempty"` + NextSyncCommitteeBranch []string `json:"next_sync_committee_branch,omitempty" hex:"true"` + FinalizedHeader *BeaconBlockHeaderJson `json:"finalized_header,omitempty"` + FinalityBranch []string `json:"finality_branch,omitempty" hex:"true"` + SyncAggregate *SyncAggregateJson `json:"sync_aggregate"` + SignatureSlot string `json:"signature_slot"` +} + +type LightClientFinalityUpdateResponseJson struct { + Version string `json:"version" enum:"true"` + Data *LightClientFinalityUpdateJson `json:"data"` +} + +type LightClientFinalityUpdateJson struct { + AttestedHeader *BeaconBlockHeaderJson `json:"attested_header"` + FinalizedHeader *BeaconBlockHeaderJson `json:"finalized_header"` + FinalityBranch []string `json:"finality_branch" hex:"true"` + SyncAggregate *SyncAggregateJson `json:"sync_aggregate"` + SignatureSlot string `json:"signature_slot"` +} + +type LightClientOptimisticUpdateResponseJson struct { + Version string `json:"version" enum:"true"` + Data *LightClientOptimisticUpdateJson `json:"data"` +} + +type LightClientOptimisticUpdateJson struct { + AttestedHeader *BeaconBlockHeaderJson `json:"attested_header"` + SyncAggregate *SyncAggregateJson `json:"sync_aggregate"` + SignatureSlot string `json:"signature_slot"` +} + type BlockHeadersResponseJson struct { Data []*BlockHeaderContainerJson `json:"data"` ExecutionOptimistic bool `json:"execution_optimistic"` @@ -353,9 +403,9 @@ type LivenessResponseJson struct { } `json:"data"` } -//---------------- +// ---------------- // Reusable types. -//---------------- +// ---------------- type CheckpointJson struct { Epoch string `json:"epoch"` @@ -1053,7 +1103,7 @@ type HistoricalSummaryJson struct { StateSummaryRoot string `json:"state_summary_root" hex:"true"` } -//---------------- +// ---------------- // SSZ // --------------- diff --git a/beacon-chain/rpc/apimiddleware/structs_marshalling.go b/beacon-chain/rpc/apimiddleware/structs_marshalling.go index f664258439ca..2a4df6cce1ef 100644 --- a/beacon-chain/rpc/apimiddleware/structs_marshalling.go +++ b/beacon-chain/rpc/apimiddleware/structs_marshalling.go @@ -2,12 +2,19 @@ package apimiddleware import ( "encoding/base64" + "encoding/json" "strconv" "strings" "github.com/pkg/errors" ) +const ( + LightClientUpdateTypeName = "light_client_update" + LightClientFinalityUpdateTypeName = "light_client_finality_update" + LightClientOptimisticUpdateTypeName = "light_client_optimistic_update" +) + // EpochParticipation represents participation of validators in their duties. type EpochParticipation []string @@ -36,3 +43,49 @@ func (p *EpochParticipation) UnmarshalJSON(b []byte) error { } return nil } + +// TypedLightClientUpdateJson is a wrapper around updates of specific types. It allows callers to send typed updates +// over a single endpoint while preserving strict typing. +type TypedLightClientUpdateJson struct { + // TypeName is the name of the update type + TypeName string `json:"type_name"` + // Data is the update of type TypeName marshaled as JSON + Data string `json:"data"` +} + +func NewTypedLightClientUpdateJsonFromUpdate(update *LightClientUpdateJson) (*TypedLightClientUpdateJson, error) { + bytes, err := json.Marshal(update) + if err != nil { + return nil, err + } + return &TypedLightClientUpdateJson{ + TypeName: LightClientUpdateTypeName, + Data: string(bytes), + }, nil +} + +func NewTypedLightClientUpdateJsonFromFinalityUpdate(update *LightClientFinalityUpdateJson) ( + *TypedLightClientUpdateJson, + error) { + bytes, err := json.Marshal(update) + if err != nil { + return nil, err + } + return &TypedLightClientUpdateJson{ + TypeName: LightClientFinalityUpdateTypeName, + Data: string(bytes), + }, nil +} + +func NewTypedLightClientUpdateJsonFromOptimisticUpdate(update *LightClientOptimisticUpdateJson) ( + *TypedLightClientUpdateJson, + error) { + bytes, err := json.Marshal(update) + if err != nil { + return nil, err + } + return &TypedLightClientUpdateJson{ + TypeName: LightClientOptimisticUpdateTypeName, + Data: string(bytes), + }, nil +} diff --git a/beacon-chain/rpc/eth/beacon/BUILD.bazel b/beacon-chain/rpc/eth/beacon/BUILD.bazel index aa02bfdd0e6a..b4c2a3953db0 100644 --- a/beacon-chain/rpc/eth/beacon/BUILD.bazel +++ b/beacon-chain/rpc/eth/beacon/BUILD.bazel @@ -7,6 +7,7 @@ go_library( "blocks.go", "config.go", "handlers.go", + "lightclient.go", "log.go", "pool.go", "server.go", @@ -37,6 +38,7 @@ go_library( "//beacon-chain/operations/voluntaryexits:go_default_library", "//beacon-chain/p2p:go_default_library", "//beacon-chain/rpc/eth/helpers:go_default_library", + "//beacon-chain/rpc/eth/helpers/lightclient:go_default_library", "//beacon-chain/rpc/lookup:go_default_library", "//beacon-chain/rpc/prysm/v1alpha1/validator:go_default_library", "//beacon-chain/state:go_default_library", diff --git a/beacon-chain/rpc/eth/beacon/lightclient.go b/beacon-chain/rpc/eth/beacon/lightclient.go new file mode 100644 index 000000000000..f964767968f2 --- /dev/null +++ b/beacon-chain/rpc/eth/beacon/lightclient.go @@ -0,0 +1,376 @@ +package beacon + +import ( + "context" + "math" + + "github.com/golang/protobuf/ptypes/empty" + "go.opencensus.io/trace" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + + lightclienthelpers "github.com/prysmaticlabs/prysm/v4/beacon-chain/rpc/eth/helpers/lightclient" + "github.com/prysmaticlabs/prysm/v4/beacon-chain/state" + "github.com/prysmaticlabs/prysm/v4/config/params" + "github.com/prysmaticlabs/prysm/v4/consensus-types/interfaces" + types "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" + "github.com/prysmaticlabs/prysm/v4/encoding/bytesutil" + ethpbv2 "github.com/prysmaticlabs/prysm/v4/proto/eth/v2" +) + +// GetLightClientBootstrap - implements https://github.com/ethereum/beacon-APIs/blob/263f4ed6c263c967f13279c7a9f5629b51c5fc55/apis/beacon/light_client/bootstrap.yaml +func (bs *Server) GetLightClientBootstrap(ctx context.Context, req *ethpbv2.LightClientBootstrapRequest) (*ethpbv2.LightClientBootstrapResponse, error) { + // Prepare + ctx, span := trace.StartSpan(ctx, "beacon.GetLightClientBootstrap") + defer span.End() + + // Get the block + var blockRoot [32]byte + copy(blockRoot[:], req.BlockRoot) + + blk, err := bs.BeaconDB.Block(ctx, blockRoot) + err = handleGetBlockError(blk, err) + if err != nil { + return nil, err + } + + // Get the state + state, err := bs.Stater.StateBySlot(ctx, blk.Block().Slot()) + if err != nil { + return nil, status.Errorf(codes.Internal, "Could not get state by slot: %v", err) + } + + bootstrap, err := lightclienthelpers.NewLightClientBootstrapFromBeaconState(ctx, state) + if err != nil { + return nil, err + } + + result := ðpbv2.LightClientBootstrapResponse{ + Version: ethpbv2.Version(blk.Version()), + Data: bootstrap, + } + + return result, nil +} + +// GetLightClientUpdatesByRange - implements https://github.com/ethereum/beacon-APIs/blob/263f4ed6c263c967f13279c7a9f5629b51c5fc55/apis/beacon/light_client/updates.yaml +func (bs *Server) GetLightClientUpdatesByRange(ctx context.Context, req *ethpbv2.LightClientUpdatesByRangeRequest) (*ethpbv2.LightClientUpdatesByRangeResponse, error) { + // Prepare + ctx, span := trace.StartSpan(ctx, "beacon.GetLightClientUpdatesByRange") + defer span.End() + + // Determine slots per period + config := params.BeaconConfig() + slotsPerPeriod := uint64(config.EpochsPerSyncCommitteePeriod) * uint64(config.SlotsPerEpoch) + + // Adjust count based on configuration + count := uint64(req.Count) + if count > config.MaxRequestLightClientUpdates { + count = config.MaxRequestLightClientUpdates + } + + // Determine the start and end periods + startPeriod := req.StartPeriod + endPeriod := startPeriod + count - 1 + + // The end of start period must be later than Altair fork epoch, otherwise, can not get the sync committee votes + startPeriodEndSlot := (startPeriod+1)*slotsPerPeriod - 1 + if startPeriodEndSlot < uint64(config.AltairForkEpoch)*uint64(config.SlotsPerEpoch) { + startPeriod = uint64(config.AltairForkEpoch) * uint64(config.SlotsPerEpoch) / slotsPerPeriod + } + + headState, err := bs.HeadFetcher.HeadState(ctx) + if err != nil { + return nil, status.Errorf(codes.Internal, "Could not get head state: %v", err) + } + + lHeadSlot := uint64(headState.Slot()) + headPeriod := lHeadSlot / slotsPerPeriod + if headPeriod < endPeriod { + endPeriod = headPeriod + } + + // Populate updates + var updates []*ethpbv2.LightClientUpdateWithVersion + for period := startPeriod; period <= endPeriod; period++ { + // Get the last known state of the period, + // 1. We wish the block has a parent in the same period if possible + // 2. We wish the block has a state in the same period + lLastSlotInPeriod := period*slotsPerPeriod + slotsPerPeriod - 1 + if lLastSlotInPeriod > lHeadSlot { + lLastSlotInPeriod = lHeadSlot + } + lFirstSlotInPeriod := period * slotsPerPeriod + + // Let's not use the first slot in the period, otherwise the attested header will be in previous period + lFirstSlotInPeriod++ + + var state state.BeaconState + var block interfaces.ReadOnlySignedBeaconBlock + for lSlot := lLastSlotInPeriod; lSlot >= lFirstSlotInPeriod; lSlot-- { + state, err = bs.Stater.StateBySlot(ctx, types.Slot(lSlot)) + if err != nil { + continue + } + + // Get the block + latestBlockHeader := *state.LatestBlockHeader() + latestStateRoot, err := state.HashTreeRoot(ctx) + if err != nil { + continue + } + latestBlockHeader.StateRoot = latestStateRoot[:] + blockRoot, err := latestBlockHeader.HashTreeRoot() + if err != nil { + continue + } + + block, err = bs.BeaconDB.Block(ctx, blockRoot) + if err != nil || block == nil { + continue + } + + syncAggregate, err := block.Block().Body().SyncAggregate() + if err != nil || syncAggregate == nil { + continue + } + + if syncAggregate.SyncCommitteeBits.Count()*3 < config.SyncCommitteeSize*2 { + // Not enough votes + continue + } + + break + } + + if block == nil { + // No valid block found for the period + continue + } + + // Get attested state + attestedRoot := block.Block().ParentRoot() + attestedBlock, err := bs.BeaconDB.Block(ctx, attestedRoot) + if err != nil || attestedBlock == nil { + continue + } + + attestedSlot := attestedBlock.Block().Slot() + attestedState, err := bs.Stater.StateBySlot(ctx, attestedSlot) + if err != nil { + continue + } + + // Get finalized block + var finalizedBlock interfaces.ReadOnlySignedBeaconBlock + finalizedCheckPoint := attestedState.FinalizedCheckpoint() + if finalizedCheckPoint != nil { + finalizedRoot := bytesutil.ToBytes32(finalizedCheckPoint.Root) + finalizedBlock, err = bs.BeaconDB.Block(ctx, finalizedRoot) + if err != nil { + finalizedBlock = nil + } + } + + update, err := lightclienthelpers.NewLightClientUpdateFromBeaconState( + ctx, + config, + slotsPerPeriod, + state, + block, + attestedState, + finalizedBlock, + ) + + if err == nil { + updates = append(updates, ðpbv2.LightClientUpdateWithVersion{ + Version: ethpbv2.Version(attestedState.Version()), + Data: update, + }) + } + } + + if len(updates) == 0 { + return nil, status.Errorf(codes.NotFound, "No updates found") + } + + result := ethpbv2.LightClientUpdatesByRangeResponse{ + Updates: updates, + } + + return &result, nil +} + +// GetLightClientFinalityUpdate - implements https://github.com/ethereum/beacon-APIs/blob/263f4ed6c263c967f13279c7a9f5629b51c5fc55/apis/beacon/light_client/finality_update.yaml +func (bs *Server) GetLightClientFinalityUpdate(ctx context.Context, + _ *empty.Empty) (*ethpbv2.LightClientFinalityUpdateResponse, error) { + // Prepare + ctx, span := trace.StartSpan(ctx, "beacon.GetLightClientFinalityUpdate") + defer span.End() + + // Finality update needs super majority of sync committee signatures + config := params.BeaconConfig() + minSignatures := uint64(math.Ceil(float64(config.MinSyncCommitteeParticipants) * 2 / 3)) + + block, err := bs.getLightClientEventBlock(ctx, minSignatures) + if err != nil { + return nil, status.Errorf(codes.Internal, "Could not get block and state: %v", err) + } + + state, err := bs.Stater.StateBySlot(ctx, block.Block().Slot()) + if err != nil { + return nil, status.Errorf(codes.Internal, "Could not get state: %v", err) + } + + // Get attested state + attestedRoot := block.Block().ParentRoot() + attestedBlock, err := bs.BeaconDB.Block(ctx, attestedRoot) + if err != nil || attestedBlock == nil { + return nil, status.Errorf(codes.Internal, "Could not get attested block: %v", err) + } + + attestedSlot := attestedBlock.Block().Slot() + attestedState, err := bs.Stater.StateBySlot(ctx, attestedSlot) + if err != nil { + return nil, status.Errorf(codes.Internal, "Could not get attested state: %v", err) + } + + // Get finalized block + var finalizedBlock interfaces.ReadOnlySignedBeaconBlock + finalizedCheckPoint := attestedState.FinalizedCheckpoint() + if finalizedCheckPoint != nil { + finalizedRoot := bytesutil.ToBytes32(finalizedCheckPoint.Root) + finalizedBlock, err = bs.BeaconDB.Block(ctx, finalizedRoot) + if err != nil { + finalizedBlock = nil + } + } + + update, err := lightclienthelpers.NewLightClientFinalityUpdateFromBeaconState( + ctx, + config, + state, + block, + attestedState, + finalizedBlock, + ) + + if err != nil { + return nil, err + } + + finalityUpdate := lightclienthelpers.NewLightClientFinalityUpdateFromUpdate(update) + + // Return the result + result := ðpbv2.LightClientFinalityUpdateResponse{ + Version: ethpbv2.Version(attestedState.Version()), + Data: finalityUpdate, + } + + return result, nil +} + +// GetLightClientOptimisticUpdate - implements https://github.com/ethereum/beacon-APIs/blob/263f4ed6c263c967f13279c7a9f5629b51c5fc55/apis/beacon/light_client/optimistic_update.yaml +func (bs *Server) GetLightClientOptimisticUpdate(ctx context.Context, + _ *empty.Empty) (*ethpbv2.LightClientOptimisticUpdateResponse, error) { + // Prepare + ctx, span := trace.StartSpan(ctx, "beacon.GetLightClientOptimisticUpdate") + defer span.End() + + config := params.BeaconConfig() + minSignatures := config.MinSyncCommitteeParticipants + + block, err := bs.getLightClientEventBlock(ctx, minSignatures) + if err != nil { + return nil, status.Errorf(codes.Internal, "Could not get block and state: %v", err) + } + + state, err := bs.Stater.StateBySlot(ctx, block.Block().Slot()) + if err != nil { + return nil, status.Errorf(codes.Internal, "Could not get state: %v", err) + } + + // Get attested state + attestedRoot := block.Block().ParentRoot() + attestedBlock, err := bs.BeaconDB.Block(ctx, attestedRoot) + if err != nil || attestedBlock == nil { + return nil, status.Errorf(codes.Internal, "Could not get attested block: %v", err) + } + + attestedSlot := attestedBlock.Block().Slot() + attestedState, err := bs.Stater.StateBySlot(ctx, attestedSlot) + if err != nil { + return nil, status.Errorf(codes.Internal, "Could not get attested state: %v", err) + } + + update, err := lightclienthelpers.NewLightClientOptimisticUpdateFromBeaconState( + ctx, + config, + state, + block, + attestedState, + ) + + if err != nil { + return nil, err + } + + optimisticUpdate := lightclienthelpers.NewLightClientOptimisticUpdateFromUpdate(update) + + // Return the result + result := ðpbv2.LightClientOptimisticUpdateResponse{ + Version: ethpbv2.Version(attestedState.Version()), + Data: optimisticUpdate, + } + + return result, nil +} + +// getLightClientEventBlock - returns the block that should be used for light client events, which satisfies the minimum number of signatures from sync committee +func (bs *Server) getLightClientEventBlock(ctx context.Context, minSignaturesRequired uint64) (interfaces.ReadOnlySignedBeaconBlock, error) { + // Get the current state + state, err := bs.HeadFetcher.HeadState(ctx) + if err != nil { + return nil, status.Errorf(codes.Internal, "Could not get head state: %v", err) + } + + // Get the block + latestBlockHeader := *state.LatestBlockHeader() + stateRoot, err := state.HashTreeRoot(ctx) + if err != nil { + return nil, status.Errorf(codes.Internal, "Could not get state root: %v", err) + } + latestBlockHeader.StateRoot = stateRoot[:] + latestBlockHeaderRoot, err := latestBlockHeader.HashTreeRoot() + if err != nil { + return nil, status.Errorf(codes.Internal, "Could not get latest block header root: %v", err) + } + + block, err := bs.BeaconDB.Block(ctx, latestBlockHeaderRoot) + if err != nil || block == nil { + return nil, status.Errorf(codes.Internal, "Could not get latest block: %v", err) + } + + // Loop through the blocks until we find a block that has super majority of sync committee signatures (2/3) + var numOfSyncCommitteeSignatures uint64 + if syncAggregate, err := block.Block().Body().SyncAggregate(); err == nil && syncAggregate != nil { + numOfSyncCommitteeSignatures = syncAggregate.SyncCommitteeBits.Count() + } + + for numOfSyncCommitteeSignatures < minSignaturesRequired { + // Get the parent block + parentRoot := block.Block().ParentRoot() + block, err = bs.BeaconDB.Block(ctx, parentRoot) + if err != nil || block == nil { + return nil, status.Errorf(codes.Internal, "Could not get parent block: %v", err) + } + + // Get the number of sync committee signatures + numOfSyncCommitteeSignatures = 0 + if syncAggregate, err := block.Block().Body().SyncAggregate(); err == nil && syncAggregate != nil { + numOfSyncCommitteeSignatures = syncAggregate.SyncCommitteeBits.Count() + } + } + + return block, nil +} diff --git a/beacon-chain/rpc/eth/events/BUILD.bazel b/beacon-chain/rpc/eth/events/BUILD.bazel index c36535c1a0ba..083fb0dea87b 100644 --- a/beacon-chain/rpc/eth/events/BUILD.bazel +++ b/beacon-chain/rpc/eth/events/BUILD.bazel @@ -20,6 +20,7 @@ go_library( "//proto/engine/v1:go_default_library", "//proto/eth/service:go_default_library", "//proto/eth/v1:go_default_library", + "//proto/eth/v2:go_default_library", "//proto/migration:go_default_library", "//runtime/version:go_default_library", "//time/slots:go_default_library", diff --git a/beacon-chain/rpc/eth/events/events.go b/beacon-chain/rpc/eth/events/events.go index ebd32c8c5325..c03450d65c46 100644 --- a/beacon-chain/rpc/eth/events/events.go +++ b/beacon-chain/rpc/eth/events/events.go @@ -15,6 +15,7 @@ import ( enginev1 "github.com/prysmaticlabs/prysm/v4/proto/engine/v1" ethpbservice "github.com/prysmaticlabs/prysm/v4/proto/eth/service" ethpb "github.com/prysmaticlabs/prysm/v4/proto/eth/v1" + ethpbv2 "github.com/prysmaticlabs/prysm/v4/proto/eth/v2" "github.com/prysmaticlabs/prysm/v4/proto/migration" "github.com/prysmaticlabs/prysm/v4/runtime/version" "github.com/prysmaticlabs/prysm/v4/time/slots" @@ -44,18 +45,24 @@ const ( BLSToExecutionChangeTopic = "bls_to_execution_change" // PayloadAttributesTopic represents a new payload attributes for execution payload building event topic. PayloadAttributesTopic = "payload_attributes" + // LightClientFinalityUpdateTopic represents a new light client finality update event topic. + LightClientFinalityUpdateTopic = "light_client_finality_update" + // LightClientOptimisticUpdateTopic represents a new light client optimistic update event topic. + LightClientOptimisticUpdateTopic = "light_client_optimistic_update" ) var casesHandled = map[string]bool{ - HeadTopic: true, - BlockTopic: true, - AttestationTopic: true, - VoluntaryExitTopic: true, - FinalizedCheckpointTopic: true, - ChainReorgTopic: true, - SyncCommitteeContributionTopic: true, - BLSToExecutionChangeTopic: true, - PayloadAttributesTopic: true, + HeadTopic: true, + BlockTopic: true, + AttestationTopic: true, + VoluntaryExitTopic: true, + FinalizedCheckpointTopic: true, + ChainReorgTopic: true, + SyncCommitteeContributionTopic: true, + BLSToExecutionChangeTopic: true, + PayloadAttributesTopic: true, + LightClientFinalityUpdateTopic: true, + LightClientOptimisticUpdateTopic: true, } // StreamEvents allows requesting all events from a set of topics defined in the Ethereum consensus API standard. @@ -243,6 +250,24 @@ func (s *Server) handleStateEvents( return nil } return streamData(stream, FinalizedCheckpointTopic, finalizedCheckpoint) + case statefeed.LightClientFinalityUpdate: + if _, ok := requestedTopics[LightClientFinalityUpdateTopic]; !ok { + return nil + } + update, ok := event.Data.(*ethpbv2.LightClientFinalityUpdateResponse) + if !ok { + return nil + } + return streamData(stream, LightClientFinalityUpdateTopic, update) + case statefeed.LightClientOptimisticUpdate: + if _, ok := requestedTopics[LightClientOptimisticUpdateTopic]; !ok { + return nil + } + update, ok := event.Data.(*ethpbv2.LightClientOptimisticUpdateResponse) + if !ok { + return nil + } + return streamData(stream, LightClientOptimisticUpdateTopic, update) case statefeed.Reorg: if _, ok := requestedTopics[ChainReorgTopic]; !ok { return nil diff --git a/beacon-chain/rpc/eth/helpers/BUILD.bazel b/beacon-chain/rpc/eth/helpers/BUILD.bazel index b72a4950bcc9..9aaa270656aa 100644 --- a/beacon-chain/rpc/eth/helpers/BUILD.bazel +++ b/beacon-chain/rpc/eth/helpers/BUILD.bazel @@ -19,9 +19,12 @@ go_library( "//beacon-chain/sync:go_default_library", "//config/params:go_default_library", "//consensus-types/primitives:go_default_library", + "//consensus-types/interfaces:go_default_library", "//encoding/bytesutil:go_default_library", - "//proto/eth/v1:go_default_library", + "//proto/eth/v2:go_default_library", + "//proto/migration:go_default_library", "//time/slots:go_default_library", + "//proto/eth/v1:go_default_library", "@com_github_pkg_errors//:go_default_library", "@org_golang_google_grpc//codes:go_default_library", "@org_golang_google_grpc//status:go_default_library", diff --git a/beacon-chain/rpc/eth/helpers/lightclient/BUILD.bazel b/beacon-chain/rpc/eth/helpers/lightclient/BUILD.bazel new file mode 100644 index 000000000000..f07a4e1f89bc --- /dev/null +++ b/beacon-chain/rpc/eth/helpers/lightclient/BUILD.bazel @@ -0,0 +1,26 @@ +load("@prysm//tools/go:def.bzl", "go_library") + +go_library( + name = "go_default_library", + srcs = [ + "lightclient.go", + ], + importpath = "github.com/prysmaticlabs/prysm/v4/beacon-chain/rpc/eth/helpers/lightclient", + visibility = ["//visibility:public"], + deps = [ + "//api/grpc:go_default_library", + "//beacon-chain/state:go_default_library", + "//beacon-chain/state/stategen:go_default_library", + "//config/params:go_default_library", + "//consensus-types/interfaces:go_default_library", + "//consensus-types/primitives:go_default_library", + "//encoding/bytesutil:go_default_library", + "//proto/eth/v1:go_default_library", + "//proto/eth/v2:go_default_library", + "//proto/migration:go_default_library", + "//time/slots:go_default_library", + "@com_github_pkg_errors//:go_default_library", + "@org_golang_google_grpc//codes:go_default_library", + "@org_golang_google_grpc//status:go_default_library", + ], +) diff --git a/beacon-chain/rpc/eth/helpers/lightclient/lightclient.go b/beacon-chain/rpc/eth/helpers/lightclient/lightclient.go new file mode 100644 index 000000000000..7db16681ff71 --- /dev/null +++ b/beacon-chain/rpc/eth/helpers/lightclient/lightclient.go @@ -0,0 +1,426 @@ +package lightclient + +import ( + "bytes" + "context" + + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + + "github.com/prysmaticlabs/prysm/v4/beacon-chain/state" + "github.com/prysmaticlabs/prysm/v4/config/params" + "github.com/prysmaticlabs/prysm/v4/consensus-types/interfaces" + types "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" + "github.com/prysmaticlabs/prysm/v4/encoding/bytesutil" + ethpbv1 "github.com/prysmaticlabs/prysm/v4/proto/eth/v1" + ethpbv2 "github.com/prysmaticlabs/prysm/v4/proto/eth/v2" + "github.com/prysmaticlabs/prysm/v4/proto/migration" + "github.com/prysmaticlabs/prysm/v4/time/slots" +) + +// NewLightClientBootstrapFromBeaconState - implements https://github.com/ethereum/consensus-specs/blob/3d235740e5f1e641d3b160c8688f26e7dc5a1894/specs/altair/light-client/full-node.md#create_light_client_bootstrap +// def create_light_client_bootstrap(state: BeaconState) -> LightClientBootstrap: +// +// assert compute_epoch_at_slot(state.slot) >= ALTAIR_FORK_EPOCH +// assert state.slot == state.latest_block_header.slot +// +// return LightClientBootstrap( +// header=BeaconBlockHeader( +// slot=state.latest_block_header.slot, +// proposer_index=state.latest_block_header.proposer_index, +// parent_root=state.latest_block_header.parent_root, +// state_root=hash_tree_root(state), +// body_root=state.latest_block_header.body_root, +// ), +// current_sync_committee=state.current_sync_committee, +// current_sync_committee_branch=compute_merkle_proof_for_state(state, CURRENT_SYNC_COMMITTEE_INDEX) +// ) +func NewLightClientBootstrapFromBeaconState(ctx context.Context, state state.BeaconState) (*ethpbv2.LightClientBootstrap, error) { + // assert compute_epoch_at_slot(state.slot) >= ALTAIR_FORK_EPOCH + if slots.ToEpoch(state.Slot()) < params.BeaconConfig().AltairForkEpoch { + return nil, status.Errorf(codes.Internal, "Invalid state slot: %d", state.Slot()) + } + + // assert state.slot == state.latest_block_header.slot + if state.Slot() != state.LatestBlockHeader().Slot { + return nil, status.Errorf(codes.Internal, "Invalid state slot: %d", state.Slot()) + } + + // Prepare data + latestBlockHeader := state.LatestBlockHeader() + + currentSyncCommittee, err := state.CurrentSyncCommittee() + if err != nil { + return nil, status.Errorf(codes.Internal, "Could not get current sync committee: %v", err) + } + + committee := ethpbv2.SyncCommittee{ + Pubkeys: currentSyncCommittee.GetPubkeys(), + AggregatePubkey: currentSyncCommittee.GetAggregatePubkey(), + } + + branch, err := state.CurrentSyncCommitteeProof(ctx) + if err != nil { + return nil, status.Errorf(codes.Internal, "Could not get current sync committee proof: %v", err) + } + + stateRoot, err := state.HashTreeRoot(ctx) + if err != nil { + return nil, status.Errorf(codes.Internal, "Could not get state root: %v", err) + } + + // Return result + result := ðpbv2.LightClientBootstrap{ + Header: ðpbv1.BeaconBlockHeader{ + Slot: latestBlockHeader.Slot, + ProposerIndex: latestBlockHeader.ProposerIndex, + ParentRoot: latestBlockHeader.ParentRoot, + StateRoot: stateRoot[:], + BodyRoot: latestBlockHeader.BodyRoot, + }, + CurrentSyncCommittee: &committee, + CurrentSyncCommitteeBranch: branch, + } + + return result, nil +} + +func NewLightClientOptimisticUpdateFromBeaconState( + ctx context.Context, + config *params.BeaconChainConfig, + state state.BeaconState, + block interfaces.ReadOnlySignedBeaconBlock, + attestedState state.BeaconState) (*ethpbv2.LightClientUpdate, error) { + // assert compute_epoch_at_slot(attested_state.slot) >= ALTAIR_FORK_EPOCH + attestedEpoch := types.Epoch(uint64(attestedState.Slot()) / uint64(config.SlotsPerEpoch)) + if attestedEpoch < types.Epoch(config.AltairForkEpoch) { + return nil, status.Errorf(codes.InvalidArgument, "Invalid attested epoch: %d", attestedEpoch) + } + + // assert sum(block.message.body.sync_aggregate.sync_committee_bits) >= MIN_SYNC_COMMITTEE_PARTICIPANTS + syncAggregate, err := block.Block().Body().SyncAggregate() + if err != nil { + return nil, status.Errorf(codes.Internal, "Could not get sync aggregate: %v", err) + } + + if syncAggregate.SyncCommitteeBits.Count() < config.MinSyncCommitteeParticipants { + return nil, status.Errorf(codes.InvalidArgument, "Invalid sync committee bits count: %d", syncAggregate.SyncCommitteeBits.Count()) + } + + // assert state.slot == state.latest_block_header.slot + if state.Slot() != state.LatestBlockHeader().Slot { + return nil, status.Errorf(codes.InvalidArgument, "Invalid state slot: %d", state.Slot()) + } + + // assert hash_tree_root(header) == hash_tree_root(block.message) + header := *state.LatestBlockHeader() + stateRoot, err := state.HashTreeRoot(ctx) + if err != nil { + return nil, status.Errorf(codes.Internal, "Could not get state root: %v", err) + } + header.StateRoot = stateRoot[:] + + headerRoot, err := header.HashTreeRoot() + if err != nil { + return nil, status.Errorf(codes.Internal, "Could not get header root: %v", err) + } + + blockRoot, err := block.Block().HashTreeRoot() + if err != nil { + return nil, status.Errorf(codes.Internal, "Could not get block root: %v", err) + } + + if headerRoot != blockRoot { + return nil, status.Errorf(codes.InvalidArgument, "Invalid header root: %v", headerRoot) + } + + // assert attested_state.slot == attested_state.latest_block_header.slot + if attestedState.Slot() != attestedState.LatestBlockHeader().Slot { + return nil, status.Errorf(codes.InvalidArgument, "Invalid attested state slot: %d", attestedState.Slot()) + } + + // attested_header = attested_state.latest_block_header.copy() + attestedHeader := *attestedState.LatestBlockHeader() + + // attested_header.state_root = hash_tree_root(attested_state) + attestedStateRoot, err := attestedState.HashTreeRoot(ctx) + if err != nil { + return nil, status.Errorf(codes.Internal, "Could not get attested state root: %v", err) + } + attestedHeader.StateRoot = attestedStateRoot[:] + + // assert hash_tree_root(attested_header) == block.message.parent_root + attestedHeaderRoot, err := attestedHeader.HashTreeRoot() + if err != nil || attestedHeaderRoot != block.Block().ParentRoot() { + return nil, status.Errorf(codes.InvalidArgument, "Invalid attested header root: %v", attestedHeaderRoot) + } + + // Return result + attestedHeaderResult := ðpbv1.BeaconBlockHeader{ + Slot: attestedHeader.Slot, + ProposerIndex: attestedHeader.ProposerIndex, + ParentRoot: attestedHeader.ParentRoot, + StateRoot: attestedHeader.StateRoot, + BodyRoot: attestedHeader.BodyRoot, + } + + syncAggregateResult := ðpbv1.SyncAggregate{ + SyncCommitteeBits: syncAggregate.SyncCommitteeBits, + SyncCommitteeSignature: syncAggregate.SyncCommitteeSignature, + } + + result := ðpbv2.LightClientUpdate{ + AttestedHeader: attestedHeaderResult, + SyncAggregate: syncAggregateResult, + SignatureSlot: block.Block().Slot(), + } + + return result, nil +} + +func NewLightClientFinalityUpdateFromBeaconState( + ctx context.Context, + config *params.BeaconChainConfig, + state state.BeaconState, + block interfaces.ReadOnlySignedBeaconBlock, + attestedState state.BeaconState, + finalizedBlock interfaces.ReadOnlySignedBeaconBlock) (*ethpbv2.LightClientUpdate, error) { + result, err := NewLightClientOptimisticUpdateFromBeaconState( + ctx, + config, + state, + block, + attestedState, + ) + if err != nil { + return nil, err + } + + // Indicate finality whenever possible + var finalizedHeader *ethpbv1.BeaconBlockHeader + var finalityBranch [][]byte + if finalizedBlock != nil && !finalizedBlock.IsNil() { + if finalizedBlock.Block().Slot() != 0 { + tempFinalizedHeader, err := finalizedBlock.Header() + if err != nil { + return nil, status.Errorf(codes.Internal, "Could not get finalized header: %v", err) + } + finalizedHeader = migration.V1Alpha1SignedHeaderToV1(tempFinalizedHeader).GetMessage() + + finalizedHeaderRoot, err := finalizedHeader.HashTreeRoot() + if err != nil { + return nil, status.Errorf(codes.Internal, "Could not get finalized header root: %v", err) + } + + if finalizedHeaderRoot != bytesutil.ToBytes32(attestedState.FinalizedCheckpoint().Root) { + return nil, status.Errorf(codes.InvalidArgument, "Invalid finalized header root: %v", finalizedHeaderRoot) + } + } else { + if !bytes.Equal(attestedState.FinalizedCheckpoint().Root, make([]byte, 32)) { + return nil, status.Errorf(codes.InvalidArgument, "Invalid finalized header root: %v", attestedState.FinalizedCheckpoint().Root) + } + + finalizedHeader = ðpbv1.BeaconBlockHeader{ + Slot: 0, + ProposerIndex: 0, + ParentRoot: make([]byte, 32), + StateRoot: make([]byte, 32), + BodyRoot: make([]byte, 32), + } + } + + finalityBranch, err = attestedState.FinalizedRootProof(ctx) + if err != nil { + return nil, status.Errorf(codes.Internal, "Could not get finalized root proof: %v", err) + } + } else { + finalizedHeader = ðpbv1.BeaconBlockHeader{ + Slot: 0, + ProposerIndex: 0, + ParentRoot: make([]byte, 32), + StateRoot: make([]byte, 32), + BodyRoot: make([]byte, 32), + } + + finalityBranch = make([][]byte, 6) + for i := 0; i < 6; i++ { + finalityBranch[i] = make([]byte, 32) + } + } + + result.FinalizedHeader = finalizedHeader + result.FinalityBranch = finalityBranch + return result, nil +} + +// NewLightClientUpdateFromBeaconState - implements https://github. +// com/ethereum/consensus-specs/blob/d70dcd9926a4bbe987f1b4e65c3e05bd029fcfb8/specs/altair/light-client/full-node.md#create_light_client_update +// def create_light_client_update(state: BeaconState, +// +// block: SignedBeaconBlock, +// attested_state: BeaconState, +// finalized_block: Optional[SignedBeaconBlock]) -> LightClientUpdate: +// assert compute_epoch_at_slot(attested_state.slot) >= ALTAIR_FORK_EPOCH +// assert sum(block.message.body.sync_aggregate.sync_committee_bits) >= MIN_SYNC_COMMITTEE_PARTICIPANTS +// +// assert state.slot == state.latest_block_header.slot +// header = state.latest_block_header.copy() +// header.state_root = hash_tree_root(state) +// assert hash_tree_root(header) == hash_tree_root(block.message) +// update_signature_period = compute_sync_committee_period(compute_epoch_at_slot(block.message.slot)) +// +// assert attested_state.slot == attested_state.latest_block_header.slot +// attested_header = attested_state.latest_block_header.copy() +// attested_header.state_root = hash_tree_root(attested_state) +// assert hash_tree_root(attested_header) == block.message.parent_root +// update_attested_period = compute_sync_committee_period(compute_epoch_at_slot(attested_header.slot)) +// +// # `next_sync_committee` is only useful if the message is signed by the current sync committee +// if update_attested_period == update_signature_period: +// next_sync_committee = attested_state.next_sync_committee +// next_sync_committee_branch = compute_merkle_proof_for_state(attested_state, NEXT_SYNC_COMMITTEE_INDEX) +// else: +// next_sync_committee = SyncCommittee() +// next_sync_committee_branch = [Bytes32() for _ in range(floorlog2(NEXT_SYNC_COMMITTEE_INDEX))] +// +// # Indicate finality whenever possible +// if finalized_block is not None: +// if finalized_block.message.slot != GENESIS_SLOT: +// finalized_header = BeaconBlockHeader( +// slot=finalized_block.message.slot, +// proposer_index=finalized_block.message.proposer_index, +// parent_root=finalized_block.message.parent_root, +// state_root=finalized_block.message.state_root, +// body_root=hash_tree_root(finalized_block.message.body), +// ) +// assert hash_tree_root(finalized_header) == attested_state.finalized_checkpoint.root +// else: +// assert attested_state.finalized_checkpoint.root == Bytes32() +// finalized_header = BeaconBlockHeader() +// finality_branch = compute_merkle_proof_for_state(attested_state, FINALIZED_ROOT_INDEX) +// else: +// finalized_header = BeaconBlockHeader() +// finality_branch = [Bytes32() for _ in range(floorlog2(FINALIZED_ROOT_INDEX))] +// +// return LightClientUpdate( +// attested_header=attested_header, +// next_sync_committee=next_sync_committee, +// next_sync_committee_branch=next_sync_committee_branch, +// finalized_header=finalized_header, +// finality_branch=finality_branch, +// sync_aggregate=block.message.body.sync_aggregate, +// signature_slot=block.message.slot, +// ) +func NewLightClientUpdateFromBeaconState( + ctx context.Context, + config *params.BeaconChainConfig, + slotsPerPeriod uint64, + state state.BeaconState, + block interfaces.ReadOnlySignedBeaconBlock, + attestedState state.BeaconState, + finalizedBlock interfaces.ReadOnlySignedBeaconBlock) (*ethpbv2.LightClientUpdate, error) { + result, err := NewLightClientFinalityUpdateFromBeaconState(ctx, config, state, block, attestedState, + finalizedBlock) + if err != nil { + return nil, err + } + + // Generate next sync committee and proof + var nextSyncCommittee *ethpbv2.SyncCommittee + var nextSyncCommitteeBranch [][]byte + + // update_signature_period = compute_sync_committee_period(compute_epoch_at_slot(block.message.slot)) + updateSignaturePeriod := uint64(block.Block().Slot()) / slotsPerPeriod + + // update_attested_period = compute_sync_committee_period(compute_epoch_at_slot(attested_header.slot)) + updateAttestedPeriod := uint64(result.AttestedHeader.Slot) / slotsPerPeriod + + if updateAttestedPeriod == updateSignaturePeriod { + tempNextSyncCommittee, err := attestedState.NextSyncCommittee() + if err != nil { + return nil, status.Errorf(codes.Internal, "Could not get next sync committee: %v", err) + } + + nextSyncCommittee = ðpbv2.SyncCommittee{ + Pubkeys: tempNextSyncCommittee.Pubkeys, + AggregatePubkey: tempNextSyncCommittee.AggregatePubkey, + } + + nextSyncCommitteeBranch, err = attestedState.NextSyncCommitteeProof(ctx) + if err != nil { + return nil, status.Errorf(codes.Internal, "Could not get next sync committee proof: %v", err) + } + } else { + pubKeys := make([][]byte, config.SyncCommitteeSize) + for i := 0; i < int(config.SyncCommitteeSize); i++ { + pubKeys[i] = make([]byte, 48) + } + nextSyncCommittee = ðpbv2.SyncCommittee{ + Pubkeys: pubKeys, + AggregatePubkey: make([]byte, 48), + } + + nextSyncCommitteeBranch = make([][]byte, 5) + for i := 0; i < 5; i++ { + nextSyncCommitteeBranch[i] = make([]byte, 32) + } + } + + result.NextSyncCommittee = nextSyncCommittee + result.NextSyncCommitteeBranch = nextSyncCommitteeBranch + return result, nil +} + +// NewLightClientFinalityUpdateFromUpdate - implements https://github.com/ethereum/consensus-specs/blob/3d235740e5f1e641d3b160c8688f26e7dc5a1894/specs/altair/light-client/full-node.md#create_light_client_finality_update +// def create_light_client_finality_update(update: LightClientUpdate) -> LightClientFinalityUpdate: +// +// return LightClientFinalityUpdate( +// attested_header=update.attested_header, +// finalized_header=update.finalized_header, +// finality_branch=update.finality_branch, +// sync_aggregate=update.sync_aggregate, +// signature_slot=update.signature_slot, +// ) +func NewLightClientFinalityUpdateFromUpdate(update *ethpbv2.LightClientUpdate) *ethpbv2.LightClientFinalityUpdate { + return ðpbv2.LightClientFinalityUpdate{ + AttestedHeader: update.AttestedHeader, + FinalizedHeader: update.FinalizedHeader, + FinalityBranch: update.FinalityBranch, + SyncAggregate: update.SyncAggregate, + SignatureSlot: update.SignatureSlot, + } +} + +// NewLightClientOptimisticUpdateFromUpdate - implements https://github.com/ethereum/consensus-specs/blob/3d235740e5f1e641d3b160c8688f26e7dc5a1894/specs/altair/light-client/full-node.md#create_light_client_optimistic_update +// def create_light_client_optimistic_update(update: LightClientUpdate) -> LightClientOptimisticUpdate: +// +// return LightClientOptimisticUpdate( +// attested_header=update.attested_header, +// sync_aggregate=update.sync_aggregate, +// signature_slot=update.signature_slot, +// ) +func NewLightClientOptimisticUpdateFromUpdate(update *ethpbv2.LightClientUpdate) *ethpbv2.LightClientOptimisticUpdate { + return ðpbv2.LightClientOptimisticUpdate{ + AttestedHeader: update.AttestedHeader, + SyncAggregate: update.SyncAggregate, + SignatureSlot: update.SignatureSlot, + } +} + +func NewLightClientUpdateFromFinalityUpdate(update *ethpbv2.LightClientFinalityUpdate) *ethpbv2.LightClientUpdate { + return ðpbv2.LightClientUpdate{ + AttestedHeader: update.AttestedHeader, + FinalizedHeader: update.FinalizedHeader, + FinalityBranch: update.FinalityBranch, + SyncAggregate: update.SyncAggregate, + SignatureSlot: update.SignatureSlot, + } +} + +func NewLightClientUpdateFromOptimisticUpdate(update *ethpbv2.LightClientOptimisticUpdate) *ethpbv2.LightClientUpdate { + return ðpbv2.LightClientUpdate{ + AttestedHeader: update.AttestedHeader, + SyncAggregate: update.SyncAggregate, + SignatureSlot: update.SignatureSlot, + } +} diff --git a/beacon-chain/state/state-native/proofs.go b/beacon-chain/state/state-native/proofs.go index cbdcfcb8eef3..9b1316757109 100644 --- a/beacon-chain/state/state-native/proofs.go +++ b/beacon-chain/state/state-native/proofs.go @@ -11,7 +11,9 @@ import ( ) const ( - finalizedRootIndex = uint64(105) // Precomputed value. + finalizedRootIndex = uint64(105) // Precomputed value. + currentSyncCommitteeIndex = uint64(54) // Precomputed value. + nextSyncCommitteeIndex = uint64(55) // Precomputed value. ) // FinalizedRootGeneralizedIndex for the beacon state. @@ -19,6 +21,16 @@ func FinalizedRootGeneralizedIndex() uint64 { return finalizedRootIndex } +// CurrentSyncCommitteeRootGeneralizedIndex for the beacon state. +func CurrentSyncCommitteeRootGeneralizedIndex() uint64 { + return currentSyncCommitteeIndex +} + +// NextSyncCommitteeRootGeneralizedIndex for the beacon state. +func NextSyncCommitteeRootGeneralizedIndex() uint64 { + return nextSyncCommitteeIndex +} + // CurrentSyncCommitteeGeneralizedIndex for the beacon state. func (b *BeaconState) CurrentSyncCommitteeGeneralizedIndex() (uint64, error) { if b.version == version.Phase0 { diff --git a/beacon-chain/state/stategen/getter.go b/beacon-chain/state/stategen/getter.go index 5f9a4fe0b531..1d104097c0f3 100644 --- a/beacon-chain/state/stategen/getter.go +++ b/beacon-chain/state/stategen/getter.go @@ -56,11 +56,7 @@ func (s *State) StateByRoot(ctx context.Context, blockRoot [32]byte) (state.Beac // Genesis case. If block root is zero hash, short circuit to use genesis state stored in DB. if blockRoot == params.BeaconConfig().ZeroHash { - root, err := s.beaconDB.GenesisBlockRoot(ctx) - if err != nil { - return nil, errors.Wrap(err, "could not get genesis block root") - } - blockRoot = root + return s.beaconDB.GenesisState(ctx) } return s.loadStateByRoot(ctx, blockRoot) } diff --git a/beacon-chain/sync/fork_watcher_test.go b/beacon-chain/sync/fork_watcher_test.go index f0441ac9e982..29333da1a93c 100644 --- a/beacon-chain/sync/fork_watcher_test.go +++ b/beacon-chain/sync/fork_watcher_test.go @@ -5,6 +5,8 @@ import ( "testing" "time" + "github.com/libp2p/go-libp2p/core/protocol" + "github.com/prysmaticlabs/prysm/v4/async/abool" mockChain "github.com/prysmaticlabs/prysm/v4/beacon-chain/blockchain/testing" "github.com/prysmaticlabs/prysm/v4/beacon-chain/p2p" @@ -93,13 +95,13 @@ func TestService_CheckForNextEpochFork(t *testing.T) { digest, err := forks.ForkDigestFromEpoch(5, genRoot[:]) assert.NoError(t, err) assert.Equal(t, true, s.subHandler.digestExists(digest)) - rpcMap := make(map[string]bool) + rpcMap := make(map[protocol.ID]bool) for _, p := range s.cfg.p2p.Host().Mux().Protocols() { - rpcMap[string(p)] = true + rpcMap[p] = true } - assert.Equal(t, true, rpcMap[p2p.RPCBlocksByRangeTopicV2+s.cfg.p2p.Encoding().ProtocolSuffix()], "topic doesn't exist") - assert.Equal(t, true, rpcMap[p2p.RPCBlocksByRootTopicV2+s.cfg.p2p.Encoding().ProtocolSuffix()], "topic doesn't exist") - assert.Equal(t, true, rpcMap[p2p.RPCMetaDataTopicV2+s.cfg.p2p.Encoding().ProtocolSuffix()], "topic doesn't exist") + assert.Equal(t, true, rpcMap[protocol.ID(p2p.RPCBlocksByRangeTopicV2+s.cfg.p2p.Encoding().ProtocolSuffix())], "topic doesn't exist") + assert.Equal(t, true, rpcMap[protocol.ID(p2p.RPCBlocksByRootTopicV2+s.cfg.p2p.Encoding().ProtocolSuffix())], "topic doesn't exist") + assert.Equal(t, true, rpcMap[protocol.ID(p2p.RPCMetaDataTopicV2+s.cfg.p2p.Encoding().ProtocolSuffix())], "topic doesn't exist") }, }, { @@ -137,9 +139,9 @@ func TestService_CheckForNextEpochFork(t *testing.T) { digest, err := forks.ForkDigestFromEpoch(5, genRoot[:]) assert.NoError(t, err) assert.Equal(t, true, s.subHandler.digestExists(digest)) - rpcMap := make(map[string]bool) + rpcMap := make(map[protocol.ID]bool) for _, p := range s.cfg.p2p.Host().Mux().Protocols() { - rpcMap[string(p)] = true + rpcMap[p] = true } }, }, @@ -193,16 +195,16 @@ func TestService_CheckForPreviousEpochFork(t *testing.T) { wantErr: false, postSvcCheck: func(t *testing.T, s *Service) { ptcls := s.cfg.p2p.Host().Mux().Protocols() - pMap := make(map[string]bool) + pMap := make(map[protocol.ID]bool) for _, p := range ptcls { - pMap[string(p)] = true + pMap[p] = true } - assert.Equal(t, true, pMap[p2p.RPCGoodByeTopicV1+s.cfg.p2p.Encoding().ProtocolSuffix()]) - assert.Equal(t, true, pMap[p2p.RPCStatusTopicV1+s.cfg.p2p.Encoding().ProtocolSuffix()]) - assert.Equal(t, true, pMap[p2p.RPCPingTopicV1+s.cfg.p2p.Encoding().ProtocolSuffix()]) - assert.Equal(t, true, pMap[p2p.RPCMetaDataTopicV1+s.cfg.p2p.Encoding().ProtocolSuffix()]) - assert.Equal(t, true, pMap[p2p.RPCBlocksByRangeTopicV1+s.cfg.p2p.Encoding().ProtocolSuffix()]) - assert.Equal(t, true, pMap[p2p.RPCBlocksByRootTopicV1+s.cfg.p2p.Encoding().ProtocolSuffix()]) + assert.Equal(t, true, pMap[protocol.ID(p2p.RPCGoodByeTopicV1+s.cfg.p2p.Encoding().ProtocolSuffix())]) + assert.Equal(t, true, pMap[protocol.ID(p2p.RPCStatusTopicV1+s.cfg.p2p.Encoding().ProtocolSuffix())]) + assert.Equal(t, true, pMap[protocol.ID(p2p.RPCPingTopicV1+s.cfg.p2p.Encoding().ProtocolSuffix())]) + assert.Equal(t, true, pMap[protocol.ID(p2p.RPCMetaDataTopicV1+s.cfg.p2p.Encoding().ProtocolSuffix())]) + assert.Equal(t, true, pMap[protocol.ID(p2p.RPCBlocksByRangeTopicV1+s.cfg.p2p.Encoding().ProtocolSuffix())]) + assert.Equal(t, true, pMap[protocol.ID(p2p.RPCBlocksByRootTopicV1+s.cfg.p2p.Encoding().ProtocolSuffix())]) }, }, { @@ -264,20 +266,20 @@ func TestService_CheckForPreviousEpochFork(t *testing.T) { assert.Equal(t, true, s.subHandler.digestExists(digest)) ptcls := s.cfg.p2p.Host().Mux().Protocols() - pMap := make(map[string]bool) + pMap := make(map[protocol.ID]bool) for _, p := range ptcls { - pMap[string(p)] = true + pMap[p] = true } - assert.Equal(t, true, pMap[p2p.RPCGoodByeTopicV1+s.cfg.p2p.Encoding().ProtocolSuffix()]) - assert.Equal(t, true, pMap[p2p.RPCStatusTopicV1+s.cfg.p2p.Encoding().ProtocolSuffix()]) - assert.Equal(t, true, pMap[p2p.RPCPingTopicV1+s.cfg.p2p.Encoding().ProtocolSuffix()]) - assert.Equal(t, true, pMap[p2p.RPCMetaDataTopicV2+s.cfg.p2p.Encoding().ProtocolSuffix()]) - assert.Equal(t, true, pMap[p2p.RPCBlocksByRangeTopicV2+s.cfg.p2p.Encoding().ProtocolSuffix()]) - assert.Equal(t, true, pMap[p2p.RPCBlocksByRootTopicV2+s.cfg.p2p.Encoding().ProtocolSuffix()]) + assert.Equal(t, true, pMap[protocol.ID(p2p.RPCGoodByeTopicV1+s.cfg.p2p.Encoding().ProtocolSuffix())]) + assert.Equal(t, true, pMap[protocol.ID(p2p.RPCStatusTopicV1+s.cfg.p2p.Encoding().ProtocolSuffix())]) + assert.Equal(t, true, pMap[protocol.ID(p2p.RPCPingTopicV1+s.cfg.p2p.Encoding().ProtocolSuffix())]) + assert.Equal(t, true, pMap[protocol.ID(p2p.RPCMetaDataTopicV2+s.cfg.p2p.Encoding().ProtocolSuffix())]) + assert.Equal(t, true, pMap[protocol.ID(p2p.RPCBlocksByRangeTopicV2+s.cfg.p2p.Encoding().ProtocolSuffix())]) + assert.Equal(t, true, pMap[protocol.ID(p2p.RPCBlocksByRootTopicV2+s.cfg.p2p.Encoding().ProtocolSuffix())]) - assert.Equal(t, false, pMap[p2p.RPCMetaDataTopicV1+s.cfg.p2p.Encoding().ProtocolSuffix()]) - assert.Equal(t, false, pMap[p2p.RPCBlocksByRangeTopicV1+s.cfg.p2p.Encoding().ProtocolSuffix()]) - assert.Equal(t, false, pMap[p2p.RPCBlocksByRootTopicV1+s.cfg.p2p.Encoding().ProtocolSuffix()]) + assert.Equal(t, false, pMap[protocol.ID(p2p.RPCMetaDataTopicV1+s.cfg.p2p.Encoding().ProtocolSuffix())]) + assert.Equal(t, false, pMap[protocol.ID(p2p.RPCBlocksByRangeTopicV1+s.cfg.p2p.Encoding().ProtocolSuffix())]) + assert.Equal(t, false, pMap[protocol.ID(p2p.RPCBlocksByRootTopicV1+s.cfg.p2p.Encoding().ProtocolSuffix())]) }, }, { diff --git a/config/params/config.go b/config/params/config.go index fd6d11aadaf3..493370c68393 100644 --- a/config/params/config.go +++ b/config/params/config.go @@ -195,7 +195,8 @@ type BeaconChainConfig struct { InactivityPenaltyQuotientBellatrix uint64 `yaml:"INACTIVITY_PENALTY_QUOTIENT_BELLATRIX" spec:"true"` // InactivityPenaltyQuotientBellatrix for penalties during inactivity post Bellatrix hard fork. // Light client - MinSyncCommitteeParticipants uint64 `yaml:"MIN_SYNC_COMMITTEE_PARTICIPANTS" spec:"true"` // MinSyncCommitteeParticipants defines the minimum amount of sync committee participants for which the light client acknowledges the signature. + MinSyncCommitteeParticipants uint64 `yaml:"MIN_SYNC_COMMITTEE_PARTICIPANTS" spec:"true"` // MinSyncCommitteeParticipants defines the minimum amount of sync committee participants for which the light client acknowledges the signature. + MaxRequestLightClientUpdates uint64 `yaml:"MAX_REQUEST_LIGHT_CLIENT_UPDATES" spec:"true"` // MaxRequestLightClientUpdates defines the maximum amount of light client updates that can be requested in a single request. // Bellatrix TerminalBlockHash common.Hash `yaml:"TERMINAL_BLOCK_HASH" spec:"true"` // TerminalBlockHash of beacon chain. diff --git a/config/params/mainnet_config.go b/config/params/mainnet_config.go index 5b856f3851eb..744a30e71195 100644 --- a/config/params/mainnet_config.go +++ b/config/params/mainnet_config.go @@ -238,7 +238,7 @@ var mainnetBeaconConfig = &BeaconChainConfig{ EpochsPerSyncCommitteePeriod: 256, // Updated penalty values. - InactivityPenaltyQuotientAltair: 3 * 1 << 24, //50331648 + InactivityPenaltyQuotientAltair: 3 * 1 << 24, // 50331648 MinSlashingPenaltyQuotientAltair: 64, ProportionalSlashingMultiplierAltair: 2, MinSlashingPenaltyQuotientBellatrix: 32, @@ -247,6 +247,7 @@ var mainnetBeaconConfig = &BeaconChainConfig{ // Light client MinSyncCommitteeParticipants: 1, + MaxRequestLightClientUpdates: 128, // Bellatrix TerminalBlockHashActivationEpoch: 18446744073709551615, diff --git a/proto/engine/v1/execution_engine.pb.go b/proto/engine/v1/execution_engine.pb.go index 0c9eb54285d8..f1626a840c2e 100755 --- a/proto/engine/v1/execution_engine.pb.go +++ b/proto/engine/v1/execution_engine.pb.go @@ -1,19 +1,18 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.30.0 -// protoc v3.15.8 +// protoc v4.23.3 // source: proto/engine/v1/execution_engine.proto package enginev1 import ( - reflect "reflect" - sync "sync" - - github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" _ "github.com/prysmaticlabs/prysm/v4/proto/eth/ext" + github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" ) const ( diff --git a/proto/eth/ext/options.pb.go b/proto/eth/ext/options.pb.go index 5095c819ecad..d2fcbc390f60 100755 --- a/proto/eth/ext/options.pb.go +++ b/proto/eth/ext/options.pb.go @@ -1,17 +1,16 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.30.0 -// protoc v3.15.8 +// protoc v4.23.3 // source: proto/eth/ext/options.proto package ext import ( - reflect "reflect" - + descriptor "github.com/golang/protobuf/protoc-gen-go/descriptor" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" - descriptorpb "google.golang.org/protobuf/types/descriptorpb" + reflect "reflect" ) const ( @@ -23,7 +22,7 @@ const ( var file_proto_eth_ext_options_proto_extTypes = []protoimpl.ExtensionInfo{ { - ExtendedType: (*descriptorpb.FieldOptions)(nil), + ExtendedType: (*descriptor.FieldOptions)(nil), ExtensionType: (*string)(nil), Field: 50000, Name: "ethereum.eth.ext.cast_type", @@ -31,7 +30,7 @@ var file_proto_eth_ext_options_proto_extTypes = []protoimpl.ExtensionInfo{ Filename: "proto/eth/ext/options.proto", }, { - ExtendedType: (*descriptorpb.FieldOptions)(nil), + ExtendedType: (*descriptor.FieldOptions)(nil), ExtensionType: (*string)(nil), Field: 50001, Name: "ethereum.eth.ext.ssz_size", @@ -39,7 +38,7 @@ var file_proto_eth_ext_options_proto_extTypes = []protoimpl.ExtensionInfo{ Filename: "proto/eth/ext/options.proto", }, { - ExtendedType: (*descriptorpb.FieldOptions)(nil), + ExtendedType: (*descriptor.FieldOptions)(nil), ExtensionType: (*string)(nil), Field: 50002, Name: "ethereum.eth.ext.ssz_max", @@ -47,7 +46,7 @@ var file_proto_eth_ext_options_proto_extTypes = []protoimpl.ExtensionInfo{ Filename: "proto/eth/ext/options.proto", }, { - ExtendedType: (*descriptorpb.FieldOptions)(nil), + ExtendedType: (*descriptor.FieldOptions)(nil), ExtensionType: (*string)(nil), Field: 50003, Name: "ethereum.eth.ext.spec_name", @@ -56,7 +55,7 @@ var file_proto_eth_ext_options_proto_extTypes = []protoimpl.ExtensionInfo{ }, } -// Extension fields to descriptorpb.FieldOptions. +// Extension fields to descriptor.FieldOptions. var ( // optional string cast_type = 50000; E_CastType = &file_proto_eth_ext_options_proto_extTypes[0] @@ -103,7 +102,7 @@ var file_proto_eth_ext_options_proto_rawDesc = []byte{ } var file_proto_eth_ext_options_proto_goTypes = []interface{}{ - (*descriptorpb.FieldOptions)(nil), // 0: google.protobuf.FieldOptions + (*descriptor.FieldOptions)(nil), // 0: google.protobuf.FieldOptions } var file_proto_eth_ext_options_proto_depIdxs = []int32{ 0, // 0: ethereum.eth.ext.cast_type:extendee -> google.protobuf.FieldOptions diff --git a/proto/eth/service/beacon_chain_service.pb.go b/proto/eth/service/beacon_chain_service.pb.go index f254aa13b0e4..7d7fe06277c5 100755 --- a/proto/eth/service/beacon_chain_service.pb.go +++ b/proto/eth/service/beacon_chain_service.pb.go @@ -1,15 +1,13 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.30.0 -// protoc v3.15.8 +// protoc v4.23.3 // source: proto/eth/service/beacon_chain_service.proto package service import ( context "context" - reflect "reflect" - _ "github.com/golang/protobuf/protoc-gen-go/descriptor" empty "github.com/golang/protobuf/ptypes/empty" v1 "github.com/prysmaticlabs/prysm/v4/proto/eth/v1" @@ -20,6 +18,7 @@ import ( status "google.golang.org/grpc/status" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" ) const ( @@ -46,442 +45,496 @@ var file_proto_eth_service_beacon_chain_service_proto_rawDesc = []byte{ 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x2e, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, - 0x32, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2e, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x74, 0x68, 0x2f, - 0x76, 0x32, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x2e, - 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x74, 0x68, - 0x2f, 0x76, 0x32, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, - 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x16, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x74, - 0x68, 0x2f, 0x76, 0x32, 0x2f, 0x73, 0x73, 0x7a, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x21, - 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x32, 0x2f, 0x73, 0x79, 0x6e, - 0x63, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x1a, 0x1e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x32, 0x2f, - 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, 0x6c, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x32, 0x9d, 0x2d, 0x0a, 0x0b, 0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x43, 0x68, 0x61, 0x69, - 0x6e, 0x12, 0x6f, 0x0a, 0x0a, 0x47, 0x65, 0x74, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x12, - 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, - 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x20, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, - 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, - 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x27, 0x82, 0xd3, 0xe4, 0x93, 0x02, - 0x21, 0x12, 0x1f, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, - 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x67, 0x65, 0x6e, 0x65, 0x73, - 0x69, 0x73, 0x12, 0x8e, 0x01, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x57, 0x65, 0x61, 0x6b, 0x53, 0x75, - 0x62, 0x6a, 0x65, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, - 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, - 0x74, 0x79, 0x1a, 0x29, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, - 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x65, 0x61, 0x6b, 0x53, 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, - 0x69, 0x76, 0x69, 0x74, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x34, 0x82, - 0xd3, 0xe4, 0x93, 0x02, 0x2b, 0x12, 0x29, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, - 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x77, - 0x65, 0x61, 0x6b, 0x5f, 0x73, 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, - 0x88, 0x02, 0x01, 0x12, 0x89, 0x01, 0x0a, 0x0c, 0x47, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, - 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x1d, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, - 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, - 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x36, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x30, 0x12, - 0x2e, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, - 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x73, 0x2f, - 0x7b, 0x73, 0x74, 0x61, 0x74, 0x65, 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x72, 0x6f, 0x6f, 0x74, 0x12, - 0x89, 0x01, 0x0a, 0x0c, 0x47, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x46, 0x6f, 0x72, 0x6b, - 0x12, 0x1d, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, - 0x76, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x22, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, - 0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x46, 0x6f, 0x72, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x22, 0x36, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x30, 0x12, 0x2e, 0x2f, 0x69, 0x6e, - 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, - 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x73, 0x2f, 0x7b, 0x73, 0x74, 0x61, - 0x74, 0x65, 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x66, 0x6f, 0x72, 0x6b, 0x12, 0xb1, 0x01, 0x0a, 0x16, - 0x47, 0x65, 0x74, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x43, 0x68, 0x65, 0x63, 0x6b, - 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x12, 0x1d, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, - 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x30, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, - 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x46, 0x69, 0x6e, - 0x61, 0x6c, 0x69, 0x74, 0x79, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x46, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x40, 0x12, - 0x3e, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, - 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x73, 0x2f, - 0x7b, 0x73, 0x74, 0x61, 0x74, 0x65, 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x66, 0x69, 0x6e, 0x61, 0x6c, - 0x69, 0x74, 0x79, 0x5f, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x12, - 0xa1, 0x01, 0x0a, 0x0e, 0x4c, 0x69, 0x73, 0x74, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, - 0x72, 0x73, 0x12, 0x27, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, - 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, - 0x74, 0x6f, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x65, 0x74, + 0x6f, 0x74, 0x6f, 0x1a, 0x25, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, + 0x32, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x5f, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x63, 0x6c, + 0x69, 0x65, 0x6e, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x32, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x5f, + 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x32, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, + 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x32, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, + 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x16, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x32, 0x2f, 0x73, 0x73, 0x7a, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x21, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x74, 0x68, + 0x2f, 0x76, 0x32, 0x2f, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, + 0x65, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, + 0x65, 0x74, 0x68, 0x2f, 0x76, 0x32, 0x2f, 0x77, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x61, + 0x6c, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0xf5, 0x32, 0x0a, 0x0b, 0x42, 0x65, 0x61, + 0x63, 0x6f, 0x6e, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x12, 0x6f, 0x0a, 0x0a, 0x47, 0x65, 0x74, 0x47, + 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x20, + 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, + 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x27, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x21, 0x12, 0x1f, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, + 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, + 0x6e, 0x2f, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x12, 0x8e, 0x01, 0x0a, 0x13, 0x47, 0x65, + 0x74, 0x57, 0x65, 0x61, 0x6b, 0x53, 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, + 0x79, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x29, 0x2e, 0x65, 0x74, 0x68, 0x65, + 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x65, 0x61, 0x6b, + 0x53, 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x34, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2b, 0x12, 0x29, 0x2f, 0x69, + 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, + 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x77, 0x65, 0x61, 0x6b, 0x5f, 0x73, 0x75, 0x62, 0x6a, 0x65, + 0x63, 0x74, 0x69, 0x76, 0x69, 0x74, 0x79, 0x88, 0x02, 0x01, 0x12, 0x89, 0x01, 0x0a, 0x0c, 0x47, + 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x1d, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, - 0x61, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3c, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x36, 0x12, 0x34, 0x2f, - 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, - 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x73, 0x2f, 0x7b, 0x73, - 0x74, 0x61, 0x74, 0x65, 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, - 0x6f, 0x72, 0x73, 0x12, 0xac, 0x01, 0x0a, 0x0c, 0x47, 0x65, 0x74, 0x56, 0x61, 0x6c, 0x69, 0x64, - 0x61, 0x74, 0x6f, 0x72, 0x12, 0x26, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, - 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x69, - 0x64, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x65, + 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x65, 0x74, 0x68, + 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x61, + 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x36, + 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x30, 0x12, 0x2e, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, + 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, + 0x73, 0x74, 0x61, 0x74, 0x65, 0x73, 0x2f, 0x7b, 0x73, 0x74, 0x61, 0x74, 0x65, 0x5f, 0x69, 0x64, + 0x7d, 0x2f, 0x72, 0x6f, 0x6f, 0x74, 0x12, 0x89, 0x01, 0x0a, 0x0c, 0x47, 0x65, 0x74, 0x53, 0x74, + 0x61, 0x74, 0x65, 0x46, 0x6f, 0x72, 0x6b, 0x12, 0x1d, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, + 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, + 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x46, 0x6f, + 0x72, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x36, 0x82, 0xd3, 0xe4, 0x93, + 0x02, 0x30, 0x12, 0x2e, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, + 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x73, 0x74, 0x61, 0x74, + 0x65, 0x73, 0x2f, 0x7b, 0x73, 0x74, 0x61, 0x74, 0x65, 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x66, 0x6f, + 0x72, 0x6b, 0x12, 0xb1, 0x01, 0x0a, 0x16, 0x47, 0x65, 0x74, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x69, + 0x74, 0x79, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x12, 0x1d, 0x2e, + 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, + 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x30, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x53, - 0x74, 0x61, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x4b, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x45, 0x12, 0x43, 0x2f, - 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, - 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x73, 0x2f, 0x7b, 0x73, - 0x74, 0x61, 0x74, 0x65, 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, - 0x6f, 0x72, 0x73, 0x2f, 0x7b, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x69, - 0x64, 0x7d, 0x12, 0xb4, 0x01, 0x0a, 0x15, 0x4c, 0x69, 0x73, 0x74, 0x56, 0x61, 0x6c, 0x69, 0x64, - 0x61, 0x74, 0x6f, 0x72, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x12, 0x29, 0x2e, 0x65, - 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x56, - 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, - 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, - 0x74, 0x6f, 0x72, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x22, 0x44, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x3e, 0x12, 0x3c, 0x2f, 0x69, 0x6e, - 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, - 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x73, 0x2f, 0x7b, 0x73, 0x74, 0x61, - 0x74, 0x65, 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, - 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x12, 0xa1, 0x01, 0x0a, 0x0e, 0x4c, 0x69, - 0x73, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, 0x73, 0x12, 0x27, 0x2e, 0x65, + 0x74, 0x61, 0x74, 0x65, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x43, 0x68, 0x65, 0x63, + 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x46, + 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x40, 0x12, 0x3e, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, + 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, + 0x73, 0x74, 0x61, 0x74, 0x65, 0x73, 0x2f, 0x7b, 0x73, 0x74, 0x61, 0x74, 0x65, 0x5f, 0x69, 0x64, + 0x7d, 0x2f, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x5f, 0x63, 0x68, 0x65, 0x63, 0x6b, + 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x12, 0xa1, 0x01, 0x0a, 0x0e, 0x4c, 0x69, 0x73, 0x74, 0x56, + 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x12, 0x27, 0x2e, 0x65, 0x74, 0x68, 0x65, + 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, + 0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, + 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, + 0x74, 0x6f, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3c, 0x82, 0xd3, + 0xe4, 0x93, 0x02, 0x36, 0x12, 0x34, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, + 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x73, 0x74, + 0x61, 0x74, 0x65, 0x73, 0x2f, 0x7b, 0x73, 0x74, 0x61, 0x74, 0x65, 0x5f, 0x69, 0x64, 0x7d, 0x2f, + 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x12, 0xac, 0x01, 0x0a, 0x0c, 0x47, + 0x65, 0x74, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x26, 0x2e, 0x65, 0x74, + 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, + 0x61, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, + 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x69, 0x64, + 0x61, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x4b, 0x82, 0xd3, + 0xe4, 0x93, 0x02, 0x45, 0x12, 0x43, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, + 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x73, 0x74, + 0x61, 0x74, 0x65, 0x73, 0x2f, 0x7b, 0x73, 0x74, 0x61, 0x74, 0x65, 0x5f, 0x69, 0x64, 0x7d, 0x2f, + 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x73, 0x2f, 0x7b, 0x76, 0x61, 0x6c, 0x69, + 0x64, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x69, 0x64, 0x7d, 0x12, 0xb4, 0x01, 0x0a, 0x15, 0x4c, 0x69, + 0x73, 0x74, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x42, 0x61, 0x6c, 0x61, 0x6e, + 0x63, 0x65, 0x73, 0x12, 0x29, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, + 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x42, + 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, + 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, + 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, + 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x44, 0x82, 0xd3, 0xe4, 0x93, + 0x02, 0x3e, 0x12, 0x3c, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, + 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x73, 0x74, 0x61, 0x74, + 0x65, 0x73, 0x2f, 0x7b, 0x73, 0x74, 0x61, 0x74, 0x65, 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x76, 0x61, + 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, + 0x12, 0xa1, 0x01, 0x0a, 0x0e, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, + 0x65, 0x65, 0x73, 0x12, 0x27, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, + 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x69, + 0x74, 0x74, 0x65, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, 0x73, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, - 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6d, - 0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0x3c, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x36, 0x12, 0x34, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, - 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, - 0x2f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x73, 0x2f, 0x7b, 0x73, 0x74, 0x61, 0x74, 0x65, 0x5f, 0x69, - 0x64, 0x7d, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, 0x73, 0x12, 0xb2, 0x01, - 0x0a, 0x12, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, - 0x74, 0x65, 0x65, 0x73, 0x12, 0x2b, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, - 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x53, 0x79, 0x6e, 0x63, - 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x1a, 0x2c, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, - 0x2e, 0x76, 0x32, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6d, - 0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0x41, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x3b, 0x12, 0x39, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, - 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, - 0x2f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x73, 0x2f, 0x7b, 0x73, 0x74, 0x61, 0x74, 0x65, 0x5f, 0x69, - 0x64, 0x7d, 0x2f, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, - 0x65, 0x73, 0x12, 0x86, 0x01, 0x0a, 0x09, 0x47, 0x65, 0x74, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, - 0x12, 0x1e, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, - 0x76, 0x32, 0x2e, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x1f, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, - 0x76, 0x32, 0x2e, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x38, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x32, 0x12, 0x30, 0x2f, 0x69, 0x6e, 0x74, 0x65, - 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, - 0x6f, 0x6e, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x73, 0x2f, 0x7b, 0x73, 0x74, 0x61, 0x74, 0x65, - 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x72, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x12, 0x88, 0x01, 0x0a, 0x10, - 0x4c, 0x69, 0x73, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, - 0x12, 0x24, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, - 0x76, 0x31, 0x2e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, - 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, - 0x61, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x27, 0x82, - 0xd3, 0xe4, 0x93, 0x02, 0x21, 0x12, 0x1f, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, - 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x68, - 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x12, 0x89, 0x01, 0x0a, 0x0e, 0x47, 0x65, 0x74, 0x42, 0x6c, - 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x1d, 0x2e, 0x65, 0x74, 0x68, 0x65, - 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6c, 0x6f, 0x63, - 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, - 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, - 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x32, - 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2c, 0x12, 0x2a, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, - 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, - 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x2f, 0x7b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x69, - 0x64, 0x7d, 0x12, 0x7d, 0x0a, 0x0b, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x42, 0x6c, 0x6f, 0x63, - 0x6b, 0x12, 0x2b, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, - 0x2e, 0x76, 0x32, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e, - 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x1a, 0x16, - 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, - 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x29, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x23, 0x3a, 0x01, - 0x2a, 0x22, 0x1e, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, - 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, - 0x73, 0x12, 0x76, 0x0a, 0x0e, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, - 0x53, 0x53, 0x5a, 0x12, 0x1d, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, - 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, 0x53, 0x53, 0x5a, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, - 0x65, 0x72, 0x1a, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x2d, 0x82, 0xd3, 0xe4, 0x93, - 0x02, 0x27, 0x3a, 0x01, 0x2a, 0x22, 0x22, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, - 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x62, - 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x2f, 0x73, 0x73, 0x7a, 0x12, 0x93, 0x01, 0x0a, 0x12, 0x53, 0x75, - 0x62, 0x6d, 0x69, 0x74, 0x42, 0x6c, 0x69, 0x6e, 0x64, 0x65, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, - 0x12, 0x32, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, - 0x76, 0x32, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x42, 0x6c, 0x69, 0x6e, 0x64, 0x65, 0x64, - 0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x43, 0x6f, 0x6e, 0x74, 0x61, - 0x69, 0x6e, 0x65, 0x72, 0x1a, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x31, 0x82, 0xd3, - 0xe4, 0x93, 0x02, 0x2b, 0x3a, 0x01, 0x2a, 0x22, 0x26, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, - 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, - 0x2f, 0x62, 0x6c, 0x69, 0x6e, 0x64, 0x65, 0x64, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x12, - 0x85, 0x01, 0x0a, 0x15, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x42, 0x6c, 0x69, 0x6e, 0x64, 0x65, - 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x53, 0x53, 0x5a, 0x12, 0x1d, 0x2e, 0x65, 0x74, 0x68, 0x65, - 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, 0x53, 0x53, 0x5a, 0x43, - 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x1a, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, - 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, - 0x22, 0x35, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2f, 0x3a, 0x01, 0x2a, 0x22, 0x2a, 0x2f, 0x69, 0x6e, - 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, - 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x62, 0x6c, 0x69, 0x6e, 0x64, 0x65, 0x64, 0x5f, 0x62, 0x6c, 0x6f, - 0x63, 0x6b, 0x73, 0x2f, 0x73, 0x73, 0x7a, 0x12, 0x89, 0x01, 0x0a, 0x0c, 0x47, 0x65, 0x74, 0x42, - 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x1d, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, - 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, - 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, - 0x6f, 0x6f, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x36, 0x82, 0xd3, 0xe4, - 0x93, 0x02, 0x30, 0x12, 0x2e, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, - 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x62, 0x6c, 0x6f, - 0x63, 0x6b, 0x73, 0x2f, 0x7b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x72, - 0x6f, 0x6f, 0x74, 0x12, 0x7f, 0x0a, 0x08, 0x47, 0x65, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x12, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3c, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x36, 0x12, 0x34, + 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, + 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x73, 0x2f, 0x7b, + 0x73, 0x74, 0x61, 0x74, 0x65, 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, + 0x74, 0x65, 0x65, 0x73, 0x12, 0xb2, 0x01, 0x0a, 0x12, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x79, 0x6e, + 0x63, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, 0x73, 0x12, 0x2b, 0x2e, 0x65, 0x74, + 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, 0x53, 0x74, + 0x61, 0x74, 0x65, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, + 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2c, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, + 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, + 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, 0x73, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x41, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x3b, 0x12, 0x39, + 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, + 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x73, 0x2f, 0x7b, + 0x73, 0x74, 0x61, 0x74, 0x65, 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x63, + 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, 0x73, 0x12, 0x86, 0x01, 0x0a, 0x09, 0x47, 0x65, + 0x74, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, 0x12, 0x1e, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, + 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, + 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, 0x52, 0x61, 0x6e, 0x64, 0x61, 0x6f, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x38, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x32, + 0x12, 0x30, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, + 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x73, + 0x2f, 0x7b, 0x73, 0x74, 0x61, 0x74, 0x65, 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x72, 0x61, 0x6e, 0x64, + 0x61, 0x6f, 0x12, 0x88, 0x01, 0x0a, 0x10, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, + 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x12, 0x24, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, + 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, + 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, + 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, + 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x27, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x21, 0x12, 0x1f, 0x2f, 0x69, + 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, + 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x12, 0x89, 0x01, + 0x0a, 0x0e, 0x47, 0x65, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, + 0x12, 0x1d, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, + 0x76, 0x31, 0x2e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x24, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, + 0x31, 0x2e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x32, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2c, 0x12, 0x2a, 0x2f, + 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, + 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x2f, 0x7b, + 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x69, 0x64, 0x7d, 0x12, 0x7d, 0x0a, 0x0b, 0x53, 0x75, 0x62, + 0x6d, 0x69, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x12, 0x2b, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, + 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x65, + 0x64, 0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x43, 0x6f, 0x6e, 0x74, + 0x61, 0x69, 0x6e, 0x65, 0x72, 0x1a, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x29, 0x82, + 0xd3, 0xe4, 0x93, 0x02, 0x23, 0x3a, 0x01, 0x2a, 0x22, 0x1e, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, + 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, + 0x6e, 0x2f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x12, 0x76, 0x0a, 0x0e, 0x53, 0x75, 0x62, 0x6d, + 0x69, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x53, 0x53, 0x5a, 0x12, 0x1d, 0x2e, 0x65, 0x74, 0x68, + 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, 0x53, 0x53, 0x5a, + 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x1a, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, + 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, + 0x79, 0x22, 0x2d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x27, 0x3a, 0x01, 0x2a, 0x22, 0x22, 0x2f, 0x69, + 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, + 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x2f, 0x73, 0x73, 0x7a, + 0x12, 0x93, 0x01, 0x0a, 0x12, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x42, 0x6c, 0x69, 0x6e, 0x64, + 0x65, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x12, 0x32, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, + 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, + 0x42, 0x6c, 0x69, 0x6e, 0x64, 0x65, 0x64, 0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x42, 0x6c, 0x6f, + 0x63, 0x6b, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x1a, 0x16, 0x2e, 0x67, 0x6f, + 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, + 0x70, 0x74, 0x79, 0x22, 0x31, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2b, 0x3a, 0x01, 0x2a, 0x22, 0x26, + 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, + 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x62, 0x6c, 0x69, 0x6e, 0x64, 0x65, 0x64, 0x5f, + 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x12, 0x85, 0x01, 0x0a, 0x15, 0x53, 0x75, 0x62, 0x6d, 0x69, + 0x74, 0x42, 0x6c, 0x69, 0x6e, 0x64, 0x65, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x53, 0x53, 0x5a, + 0x12, 0x1d, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, + 0x76, 0x32, 0x2e, 0x53, 0x53, 0x5a, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x1a, + 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, + 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x35, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2f, 0x3a, + 0x01, 0x2a, 0x22, 0x2a, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, + 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x62, 0x6c, 0x69, 0x6e, + 0x64, 0x65, 0x64, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x2f, 0x73, 0x73, 0x7a, 0x12, 0x89, + 0x01, 0x0a, 0x0c, 0x47, 0x65, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x1d, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, - 0x31, 0x2e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, + 0x31, 0x2e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, - 0x2e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x34, - 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2b, 0x12, 0x29, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, - 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, + 0x2e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x22, 0x36, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x30, 0x12, 0x2e, 0x2f, 0x69, 0x6e, 0x74, + 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, + 0x63, 0x6f, 0x6e, 0x2f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x2f, 0x7b, 0x62, 0x6c, 0x6f, 0x63, + 0x6b, 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x72, 0x6f, 0x6f, 0x74, 0x12, 0x7f, 0x0a, 0x08, 0x47, 0x65, + 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x12, 0x1d, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, + 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, + 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x34, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2b, 0x12, 0x29, 0x2f, + 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, + 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x2f, 0x7b, 0x62, + 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x69, 0x64, 0x7d, 0x88, 0x02, 0x01, 0x12, 0x89, 0x01, 0x0a, 0x0b, + 0x47, 0x65, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x53, 0x53, 0x5a, 0x12, 0x1d, 0x2e, 0x65, 0x74, + 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6c, + 0x6f, 0x63, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x65, 0x74, 0x68, + 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6c, 0x6f, + 0x63, 0x6b, 0x53, 0x53, 0x5a, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x38, 0x82, + 0xd3, 0xe4, 0x93, 0x02, 0x2f, 0x12, 0x2d, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, + 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x62, + 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x2f, 0x7b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x69, 0x64, 0x7d, + 0x2f, 0x73, 0x73, 0x7a, 0x88, 0x02, 0x01, 0x12, 0x82, 0x01, 0x0a, 0x0a, 0x47, 0x65, 0x74, 0x42, + 0x6c, 0x6f, 0x63, 0x6b, 0x56, 0x32, 0x12, 0x1f, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, + 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x56, 0x32, 0x1a, 0x20, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, + 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x56, 0x32, 0x22, 0x31, 0x82, 0xd3, 0xe4, 0x93, 0x02, + 0x2b, 0x12, 0x29, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, + 0x2f, 0x76, 0x32, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, + 0x73, 0x2f, 0x7b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x69, 0x64, 0x7d, 0x12, 0x92, 0x01, 0x0a, + 0x0f, 0x47, 0x65, 0x74, 0x42, 0x6c, 0x69, 0x6e, 0x64, 0x65, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, + 0x12, 0x1d, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, + 0x76, 0x31, 0x2e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x25, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, + 0x32, 0x2e, 0x42, 0x6c, 0x69, 0x6e, 0x64, 0x65, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x39, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x33, 0x12, 0x31, + 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, + 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x62, 0x6c, 0x69, 0x6e, 0x64, 0x65, 0x64, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x2f, 0x7b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x69, 0x64, - 0x7d, 0x88, 0x02, 0x01, 0x12, 0x89, 0x01, 0x0a, 0x0b, 0x47, 0x65, 0x74, 0x42, 0x6c, 0x6f, 0x63, - 0x6b, 0x53, 0x53, 0x5a, 0x12, 0x1d, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, - 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, - 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x53, 0x53, 0x5a, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x38, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2f, 0x12, 0x2d, + 0x7d, 0x12, 0x91, 0x01, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x42, 0x6c, 0x69, 0x6e, 0x64, 0x65, 0x64, + 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x53, 0x53, 0x5a, 0x12, 0x1d, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, + 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, + 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, 0x53, 0x53, 0x5a, 0x43, 0x6f, 0x6e, + 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x22, 0x3d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x37, 0x12, 0x35, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, - 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x2f, 0x7b, - 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x73, 0x73, 0x7a, 0x88, 0x02, 0x01, - 0x12, 0x82, 0x01, 0x0a, 0x0a, 0x47, 0x65, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x56, 0x32, 0x12, - 0x1f, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, - 0x32, 0x2e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x56, 0x32, - 0x1a, 0x20, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, - 0x76, 0x32, 0x2e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x56, 0x32, 0x22, 0x31, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2b, 0x12, 0x29, 0x2f, 0x69, 0x6e, 0x74, - 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x32, 0x2f, 0x62, 0x65, 0x61, - 0x63, 0x6f, 0x6e, 0x2f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x2f, 0x7b, 0x62, 0x6c, 0x6f, 0x63, - 0x6b, 0x5f, 0x69, 0x64, 0x7d, 0x12, 0x92, 0x01, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x42, 0x6c, 0x69, - 0x6e, 0x64, 0x65, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x12, 0x1d, 0x2e, 0x65, 0x74, 0x68, 0x65, - 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6c, 0x6f, 0x63, - 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, - 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, 0x42, 0x6c, 0x69, 0x6e, 0x64, - 0x65, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0x39, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x33, 0x12, 0x31, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, - 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, - 0x2f, 0x62, 0x6c, 0x69, 0x6e, 0x64, 0x65, 0x64, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x2f, - 0x7b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x69, 0x64, 0x7d, 0x12, 0x91, 0x01, 0x0a, 0x12, 0x47, - 0x65, 0x74, 0x42, 0x6c, 0x69, 0x6e, 0x64, 0x65, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x53, 0x53, - 0x5a, 0x12, 0x1d, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, - 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x1d, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, - 0x76, 0x32, 0x2e, 0x53, 0x53, 0x5a, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x22, - 0x3d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x37, 0x12, 0x35, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, - 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, - 0x2f, 0x62, 0x6c, 0x69, 0x6e, 0x64, 0x65, 0x64, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x2f, - 0x7b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x73, 0x73, 0x7a, 0x12, 0x86, - 0x01, 0x0a, 0x0d, 0x47, 0x65, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x53, 0x53, 0x5a, 0x56, 0x32, - 0x12, 0x1f, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, - 0x76, 0x32, 0x2e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x56, - 0x32, 0x1a, 0x1d, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, - 0x2e, 0x76, 0x32, 0x2e, 0x53, 0x53, 0x5a, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, - 0x22, 0x35, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2f, 0x12, 0x2d, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, - 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x32, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, - 0x6e, 0x2f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x2f, 0x7b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, - 0x69, 0x64, 0x7d, 0x2f, 0x73, 0x73, 0x7a, 0x12, 0xa2, 0x01, 0x0a, 0x15, 0x4c, 0x69, 0x73, 0x74, - 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x73, 0x12, 0x1d, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, - 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x2a, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, - 0x76, 0x31, 0x2e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3e, 0x82, 0xd3, - 0xe4, 0x93, 0x02, 0x38, 0x12, 0x36, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, - 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x62, 0x6c, - 0x6f, 0x63, 0x6b, 0x73, 0x2f, 0x7b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x69, 0x64, 0x7d, 0x2f, - 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x9e, 0x01, 0x0a, - 0x14, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x6f, 0x6f, 0x6c, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x28, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, - 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x73, 0x50, 0x6f, 0x6f, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x29, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, - 0x31, 0x2e, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x50, 0x6f, - 0x6f, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x31, 0x82, 0xd3, 0xe4, 0x93, - 0x02, 0x2b, 0x12, 0x29, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, - 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x70, 0x6f, 0x6f, 0x6c, - 0x2f, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x8e, 0x01, - 0x0a, 0x12, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x2a, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, - 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x41, 0x74, 0x74, - 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, - 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x34, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2e, - 0x3a, 0x01, 0x2a, 0x22, 0x29, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, + 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x62, 0x6c, 0x69, 0x6e, 0x64, 0x65, 0x64, 0x5f, + 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x2f, 0x7b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x69, 0x64, + 0x7d, 0x2f, 0x73, 0x73, 0x7a, 0x12, 0x86, 0x01, 0x0a, 0x0d, 0x47, 0x65, 0x74, 0x42, 0x6c, 0x6f, + 0x63, 0x6b, 0x53, 0x53, 0x5a, 0x56, 0x32, 0x12, 0x1f, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, + 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x56, 0x32, 0x1a, 0x1d, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, + 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, 0x53, 0x53, 0x5a, 0x43, 0x6f, + 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x22, 0x35, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2f, 0x12, + 0x2d, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, + 0x32, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x2f, + 0x7b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x73, 0x73, 0x7a, 0x12, 0xa2, + 0x01, 0x0a, 0x15, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x41, 0x74, 0x74, 0x65, + 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x1d, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, + 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, + 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x41, + 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x3e, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x38, 0x12, 0x36, 0x2f, 0x69, 0x6e, + 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, + 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x2f, 0x7b, 0x62, 0x6c, 0x6f, + 0x63, 0x6b, 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x12, 0x9e, 0x01, 0x0a, 0x14, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x6f, 0x6f, 0x6c, + 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x28, 0x2e, 0x65, + 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x41, + 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x50, 0x6f, 0x6f, 0x6c, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, + 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x50, 0x6f, 0x6f, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x31, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2b, 0x12, 0x29, 0x2f, 0x69, 0x6e, 0x74, 0x65, + 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, + 0x6f, 0x6e, 0x2f, 0x70, 0x6f, 0x6f, 0x6c, 0x2f, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x8e, 0x01, 0x0a, 0x12, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x41, + 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x2a, 0x2e, 0x65, 0x74, + 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x75, + 0x62, 0x6d, 0x69, 0x74, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, + 0x34, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2e, 0x3a, 0x01, 0x2a, 0x22, 0x29, 0x2f, 0x69, 0x6e, 0x74, + 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, + 0x63, 0x6f, 0x6e, 0x2f, 0x70, 0x6f, 0x6f, 0x6c, 0x2f, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x9c, 0x01, 0x0a, 0x19, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x6f, + 0x6f, 0x6c, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x65, 0x72, 0x53, 0x6c, 0x61, 0x73, 0x68, 0x69, + 0x6e, 0x67, 0x73, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x2e, 0x2e, 0x65, 0x74, + 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x74, + 0x74, 0x65, 0x73, 0x74, 0x65, 0x72, 0x53, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x73, 0x50, + 0x6f, 0x6f, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x37, 0x82, 0xd3, 0xe4, + 0x93, 0x02, 0x31, 0x12, 0x2f, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x70, 0x6f, 0x6f, - 0x6c, 0x2f, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x9c, - 0x01, 0x0a, 0x19, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x6f, 0x6f, 0x6c, 0x41, 0x74, 0x74, 0x65, 0x73, - 0x74, 0x65, 0x72, 0x53, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x16, 0x2e, 0x67, - 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, - 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x2e, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, - 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x65, 0x72, 0x53, - 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x73, 0x50, 0x6f, 0x6f, 0x6c, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x37, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x31, 0x12, 0x2f, 0x2f, 0x69, - 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, - 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x70, 0x6f, 0x6f, 0x6c, 0x2f, 0x61, 0x74, 0x74, 0x65, 0x73, - 0x74, 0x65, 0x72, 0x5f, 0x73, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x8f, 0x01, - 0x0a, 0x16, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x65, 0x72, - 0x53, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x12, 0x21, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, - 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x74, 0x74, 0x65, 0x73, - 0x74, 0x65, 0x72, 0x53, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x1a, 0x16, 0x2e, 0x67, 0x6f, - 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, - 0x70, 0x74, 0x79, 0x22, 0x3a, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x34, 0x3a, 0x01, 0x2a, 0x22, 0x2f, - 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, - 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x70, 0x6f, 0x6f, 0x6c, 0x2f, 0x61, 0x74, 0x74, - 0x65, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x73, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x73, 0x12, - 0x9b, 0x01, 0x0a, 0x19, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x6f, 0x6f, 0x6c, 0x50, 0x72, 0x6f, 0x70, - 0x6f, 0x73, 0x65, 0x72, 0x53, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x16, 0x2e, - 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, - 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x2d, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, - 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, - 0x53, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x50, 0x6f, 0x6f, 0x6c, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x37, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x31, 0x12, 0x2f, 0x2f, 0x69, - 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, - 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x70, 0x6f, 0x6f, 0x6c, 0x2f, 0x70, 0x72, 0x6f, 0x70, 0x6f, - 0x73, 0x65, 0x72, 0x5f, 0x73, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x8f, 0x01, - 0x0a, 0x16, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, - 0x53, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x12, 0x21, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, - 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x72, 0x6f, 0x70, 0x6f, - 0x73, 0x65, 0x72, 0x53, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x1a, 0x16, 0x2e, 0x67, 0x6f, - 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, - 0x70, 0x74, 0x79, 0x22, 0x3a, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x34, 0x3a, 0x01, 0x2a, 0x22, 0x2f, + 0x6c, 0x2f, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x73, 0x6c, 0x61, 0x73, 0x68, + 0x69, 0x6e, 0x67, 0x73, 0x12, 0x8f, 0x01, 0x0a, 0x16, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x41, + 0x74, 0x74, 0x65, 0x73, 0x74, 0x65, 0x72, 0x53, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x12, + 0x21, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, + 0x31, 0x2e, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x65, 0x72, 0x53, 0x6c, 0x61, 0x73, 0x68, 0x69, + 0x6e, 0x67, 0x1a, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x3a, 0x82, 0xd3, 0xe4, 0x93, + 0x02, 0x34, 0x3a, 0x01, 0x2a, 0x22, 0x2f, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, + 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x70, + 0x6f, 0x6f, 0x6c, 0x2f, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x73, 0x6c, 0x61, + 0x73, 0x68, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x9b, 0x01, 0x0a, 0x19, 0x4c, 0x69, 0x73, 0x74, 0x50, + 0x6f, 0x6f, 0x6c, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x53, 0x6c, 0x61, 0x73, 0x68, + 0x69, 0x6e, 0x67, 0x73, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x2d, 0x2e, 0x65, + 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x50, + 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x53, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x50, + 0x6f, 0x6f, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x37, 0x82, 0xd3, 0xe4, + 0x93, 0x02, 0x31, 0x12, 0x2f, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, + 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x70, 0x6f, 0x6f, + 0x6c, 0x2f, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x5f, 0x73, 0x6c, 0x61, 0x73, 0x68, + 0x69, 0x6e, 0x67, 0x73, 0x12, 0x8f, 0x01, 0x0a, 0x16, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x50, + 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x53, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x12, + 0x21, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, + 0x31, 0x2e, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x53, 0x6c, 0x61, 0x73, 0x68, 0x69, + 0x6e, 0x67, 0x1a, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x3a, 0x82, 0xd3, 0xe4, 0x93, + 0x02, 0x34, 0x3a, 0x01, 0x2a, 0x22, 0x2f, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, + 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x70, + 0x6f, 0x6f, 0x6c, 0x2f, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x65, 0x72, 0x5f, 0x73, 0x6c, 0x61, + 0x73, 0x68, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x93, 0x01, 0x0a, 0x16, 0x4c, 0x69, 0x73, 0x74, 0x50, + 0x6f, 0x6f, 0x6c, 0x56, 0x6f, 0x6c, 0x75, 0x6e, 0x74, 0x61, 0x72, 0x79, 0x45, 0x78, 0x69, 0x74, + 0x73, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x2b, 0x2e, 0x65, 0x74, 0x68, 0x65, + 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x6f, 0x6c, 0x75, + 0x6e, 0x74, 0x61, 0x72, 0x79, 0x45, 0x78, 0x69, 0x74, 0x73, 0x50, 0x6f, 0x6f, 0x6c, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x34, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2e, 0x12, 0x2c, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, - 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x70, 0x6f, 0x6f, 0x6c, 0x2f, 0x70, 0x72, 0x6f, - 0x70, 0x6f, 0x73, 0x65, 0x72, 0x5f, 0x73, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x73, 0x12, - 0x93, 0x01, 0x0a, 0x16, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x6f, 0x6f, 0x6c, 0x56, 0x6f, 0x6c, 0x75, - 0x6e, 0x74, 0x61, 0x72, 0x79, 0x45, 0x78, 0x69, 0x74, 0x73, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, + 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x70, 0x6f, 0x6f, 0x6c, 0x2f, 0x76, 0x6f, 0x6c, + 0x75, 0x6e, 0x74, 0x61, 0x72, 0x79, 0x5f, 0x65, 0x78, 0x69, 0x74, 0x73, 0x12, 0x8c, 0x01, 0x0a, + 0x13, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x56, 0x6f, 0x6c, 0x75, 0x6e, 0x74, 0x61, 0x72, 0x79, + 0x45, 0x78, 0x69, 0x74, 0x12, 0x24, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, + 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x56, 0x6f, 0x6c, + 0x75, 0x6e, 0x74, 0x61, 0x72, 0x79, 0x45, 0x78, 0x69, 0x74, 0x1a, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, - 0x74, 0x79, 0x1a, 0x2b, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, - 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x56, 0x6f, 0x6c, 0x75, 0x6e, 0x74, 0x61, 0x72, 0x79, 0x45, 0x78, - 0x69, 0x74, 0x73, 0x50, 0x6f, 0x6f, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0x34, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2e, 0x12, 0x2c, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, - 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, - 0x2f, 0x70, 0x6f, 0x6f, 0x6c, 0x2f, 0x76, 0x6f, 0x6c, 0x75, 0x6e, 0x74, 0x61, 0x72, 0x79, 0x5f, - 0x65, 0x78, 0x69, 0x74, 0x73, 0x12, 0x8c, 0x01, 0x0a, 0x13, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, - 0x56, 0x6f, 0x6c, 0x75, 0x6e, 0x74, 0x61, 0x72, 0x79, 0x45, 0x78, 0x69, 0x74, 0x12, 0x24, 0x2e, - 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, - 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x56, 0x6f, 0x6c, 0x75, 0x6e, 0x74, 0x61, 0x72, 0x79, 0x45, - 0x78, 0x69, 0x74, 0x1a, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x37, 0x82, 0xd3, 0xe4, - 0x93, 0x02, 0x31, 0x3a, 0x01, 0x2a, 0x22, 0x2c, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, - 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, - 0x70, 0x6f, 0x6f, 0x6c, 0x2f, 0x76, 0x6f, 0x6c, 0x75, 0x6e, 0x74, 0x61, 0x72, 0x79, 0x5f, 0x65, - 0x78, 0x69, 0x74, 0x73, 0x12, 0xb2, 0x01, 0x0a, 0x21, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x53, - 0x69, 0x67, 0x6e, 0x65, 0x64, 0x42, 0x4c, 0x53, 0x54, 0x6f, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, - 0x69, 0x6f, 0x6e, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x12, 0x33, 0x2e, 0x65, 0x74, 0x68, - 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, 0x53, 0x75, 0x62, - 0x6d, 0x69, 0x74, 0x42, 0x4c, 0x53, 0x54, 0x6f, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, - 0x6e, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, - 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x40, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x3a, 0x3a, - 0x01, 0x2a, 0x22, 0x35, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, - 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x70, 0x6f, 0x6f, 0x6c, - 0x2f, 0x62, 0x6c, 0x73, 0x5f, 0x74, 0x6f, 0x5f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, - 0x6e, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x12, 0xa8, 0x01, 0x0a, 0x21, 0x53, 0x75, - 0x62, 0x6d, 0x69, 0x74, 0x50, 0x6f, 0x6f, 0x6c, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6d, 0x6d, - 0x69, 0x74, 0x74, 0x65, 0x65, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x12, - 0x32, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, - 0x32, 0x2e, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x50, 0x6f, 0x6f, 0x6c, 0x53, 0x79, 0x6e, 0x63, - 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, - 0x72, 0x65, 0x73, 0x1a, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x37, 0x82, 0xd3, 0xe4, - 0x93, 0x02, 0x31, 0x3a, 0x01, 0x2a, 0x22, 0x2c, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, - 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, - 0x70, 0x6f, 0x6f, 0x6c, 0x2f, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, - 0x74, 0x65, 0x65, 0x73, 0x12, 0xa6, 0x01, 0x0a, 0x19, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x4c, 0x53, - 0x54, 0x6f, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x68, 0x61, 0x6e, 0x67, - 0x65, 0x73, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x32, 0x2e, 0x65, 0x74, 0x68, - 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, 0x42, 0x4c, 0x53, - 0x54, 0x6f, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x68, 0x61, 0x6e, 0x67, - 0x65, 0x73, 0x50, 0x6f, 0x6f, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3d, - 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x37, 0x12, 0x35, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, - 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, - 0x70, 0x6f, 0x6f, 0x6c, 0x2f, 0x62, 0x6c, 0x73, 0x5f, 0x74, 0x6f, 0x5f, 0x65, 0x78, 0x65, 0x63, - 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x12, 0x7f, 0x0a, - 0x0f, 0x47, 0x65, 0x74, 0x46, 0x6f, 0x72, 0x6b, 0x53, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, - 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, - 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x25, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, - 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x46, 0x6f, 0x72, 0x6b, 0x53, - 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0x2d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x27, 0x12, 0x25, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, - 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, - 0x2f, 0x66, 0x6f, 0x72, 0x6b, 0x5f, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x12, 0x66, - 0x0a, 0x07, 0x47, 0x65, 0x74, 0x53, 0x70, 0x65, 0x63, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, + 0x74, 0x79, 0x22, 0x37, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x31, 0x3a, 0x01, 0x2a, 0x22, 0x2c, 0x2f, + 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, + 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x70, 0x6f, 0x6f, 0x6c, 0x2f, 0x76, 0x6f, 0x6c, 0x75, + 0x6e, 0x74, 0x61, 0x72, 0x79, 0x5f, 0x65, 0x78, 0x69, 0x74, 0x73, 0x12, 0xb2, 0x01, 0x0a, 0x21, + 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x42, 0x4c, 0x53, 0x54, + 0x6f, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, + 0x73, 0x12, 0x33, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, + 0x2e, 0x76, 0x32, 0x2e, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x42, 0x4c, 0x53, 0x54, 0x6f, 0x45, + 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x40, + 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x3a, 0x3a, 0x01, 0x2a, 0x22, 0x35, 0x2f, 0x69, 0x6e, 0x74, 0x65, + 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, + 0x6f, 0x6e, 0x2f, 0x70, 0x6f, 0x6f, 0x6c, 0x2f, 0x62, 0x6c, 0x73, 0x5f, 0x74, 0x6f, 0x5f, 0x65, + 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x73, + 0x12, 0xa8, 0x01, 0x0a, 0x21, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x50, 0x6f, 0x6f, 0x6c, 0x53, + 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, 0x53, 0x69, 0x67, 0x6e, + 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x12, 0x32, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, + 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, 0x53, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x50, + 0x6f, 0x6f, 0x6c, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, + 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x1a, 0x16, 0x2e, 0x67, 0x6f, 0x6f, + 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, + 0x74, 0x79, 0x22, 0x37, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x31, 0x3a, 0x01, 0x2a, 0x22, 0x2c, 0x2f, + 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, + 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x70, 0x6f, 0x6f, 0x6c, 0x2f, 0x73, 0x79, 0x6e, 0x63, + 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, 0x73, 0x12, 0xa6, 0x01, 0x0a, 0x19, + 0x4c, 0x69, 0x73, 0x74, 0x42, 0x4c, 0x53, 0x54, 0x6f, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, + 0x6f, 0x6e, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, - 0x79, 0x1a, 0x1d, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, - 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x70, 0x65, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0x24, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1e, 0x12, 0x1c, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, - 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x6f, 0x6e, 0x66, 0x69, - 0x67, 0x2f, 0x73, 0x70, 0x65, 0x63, 0x12, 0x88, 0x01, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x44, 0x65, - 0x70, 0x6f, 0x73, 0x69, 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x12, 0x16, 0x2e, - 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, - 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x28, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, - 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x43, - 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0x30, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2a, 0x12, 0x28, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, - 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, - 0x2f, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, - 0x74, 0x42, 0x98, 0x01, 0x0a, 0x18, 0x6f, 0x72, 0x67, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, - 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x42, 0x17, - 0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x69, - 0x63, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, - 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, - 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x34, 0x2f, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0xaa, 0x02, - 0x14, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x45, 0x74, 0x68, 0x2e, 0x53, 0x65, - 0x72, 0x76, 0x69, 0x63, 0x65, 0xca, 0x02, 0x14, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, - 0x5c, 0x45, 0x74, 0x68, 0x5c, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x62, 0x06, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x33, + 0x79, 0x1a, 0x32, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, + 0x2e, 0x76, 0x32, 0x2e, 0x42, 0x4c, 0x53, 0x54, 0x6f, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, + 0x6f, 0x6e, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x50, 0x6f, 0x6f, 0x6c, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x37, 0x12, 0x35, 0x2f, + 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, + 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, 0x70, 0x6f, 0x6f, 0x6c, 0x2f, 0x62, 0x6c, 0x73, 0x5f, + 0x74, 0x6f, 0x5f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x68, 0x61, + 0x6e, 0x67, 0x65, 0x73, 0x12, 0x7f, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x46, 0x6f, 0x72, 0x6b, 0x53, + 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, + 0x25, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, + 0x31, 0x2e, 0x46, 0x6f, 0x72, 0x6b, 0x53, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x27, 0x12, 0x25, + 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, + 0x2f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2f, 0x66, 0x6f, 0x72, 0x6b, 0x5f, 0x73, 0x63, 0x68, + 0x65, 0x64, 0x75, 0x6c, 0x65, 0x12, 0x66, 0x0a, 0x07, 0x47, 0x65, 0x74, 0x53, 0x70, 0x65, 0x63, + 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x1d, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, + 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x70, 0x65, 0x63, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x24, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1e, 0x12, + 0x1c, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, + 0x31, 0x2f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2f, 0x73, 0x70, 0x65, 0x63, 0x12, 0x88, 0x01, + 0x0a, 0x12, 0x47, 0x65, 0x74, 0x44, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x61, 0x63, 0x74, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x28, 0x2e, 0x65, + 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x44, + 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x30, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2a, 0x12, 0x28, + 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, + 0x2f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2f, 0x64, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x5f, + 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x12, 0xbb, 0x01, 0x0a, 0x17, 0x47, 0x65, 0x74, + 0x4c, 0x69, 0x67, 0x68, 0x74, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x42, 0x6f, 0x6f, 0x74, 0x73, + 0x74, 0x72, 0x61, 0x70, 0x12, 0x2c, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, + 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x43, 0x6c, 0x69, 0x65, + 0x6e, 0x74, 0x42, 0x6f, 0x6f, 0x74, 0x73, 0x74, 0x72, 0x61, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x2d, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, + 0x68, 0x2e, 0x76, 0x32, 0x2e, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, + 0x42, 0x6f, 0x6f, 0x74, 0x73, 0x74, 0x72, 0x61, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x43, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x3d, 0x12, 0x3b, 0x2f, 0x69, 0x6e, 0x74, 0x65, + 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, + 0x6f, 0x6e, 0x2f, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x5f, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2f, + 0x62, 0x6f, 0x6f, 0x74, 0x73, 0x74, 0x72, 0x61, 0x70, 0x2f, 0x7b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, + 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x7d, 0x12, 0xbb, 0x01, 0x0a, 0x1c, 0x47, 0x65, 0x74, 0x4c, 0x69, + 0x67, 0x68, 0x74, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, + 0x42, 0x79, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x31, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, + 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x43, + 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, 0x42, 0x79, 0x52, 0x61, + 0x6e, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x32, 0x2e, 0x65, 0x74, 0x68, + 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, 0x4c, 0x69, 0x67, + 0x68, 0x74, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, 0x42, + 0x79, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x34, + 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2e, 0x12, 0x2c, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, + 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x2f, + 0x6c, 0x69, 0x67, 0x68, 0x74, 0x5f, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2f, 0x75, 0x70, 0x64, + 0x61, 0x74, 0x65, 0x73, 0x12, 0xa8, 0x01, 0x0a, 0x1c, 0x47, 0x65, 0x74, 0x4c, 0x69, 0x67, 0x68, + 0x74, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x55, + 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x32, 0x2e, + 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, + 0x4c, 0x69, 0x67, 0x68, 0x74, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x46, 0x69, 0x6e, 0x61, 0x6c, + 0x69, 0x74, 0x79, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x3c, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x36, 0x12, 0x34, 0x2f, 0x69, 0x6e, 0x74, 0x65, + 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, + 0x6f, 0x6e, 0x2f, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x5f, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2f, + 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, + 0xae, 0x01, 0x0a, 0x1e, 0x47, 0x65, 0x74, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x43, 0x6c, 0x69, 0x65, + 0x6e, 0x74, 0x4f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x73, 0x74, 0x69, 0x63, 0x55, 0x70, 0x64, 0x61, + 0x74, 0x65, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x34, 0x2e, 0x65, 0x74, 0x68, + 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, 0x4c, 0x69, 0x67, + 0x68, 0x74, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x4f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x73, 0x74, + 0x69, 0x63, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x3e, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x38, 0x12, 0x36, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, + 0x6e, 0x61, 0x6c, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, + 0x6e, 0x2f, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x5f, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2f, 0x6f, + 0x70, 0x74, 0x69, 0x6d, 0x69, 0x73, 0x74, 0x69, 0x63, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, + 0x42, 0x98, 0x01, 0x0a, 0x18, 0x6f, 0x72, 0x67, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, + 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x42, 0x17, 0x42, + 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, + 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, + 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, 0x61, + 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x34, 0x2f, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0xaa, 0x02, 0x14, + 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x45, 0x74, 0x68, 0x2e, 0x53, 0x65, 0x72, + 0x76, 0x69, 0x63, 0x65, 0xca, 0x02, 0x14, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x5c, + 0x45, 0x74, 0x68, 0x5c, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x62, 0x06, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x33, } var file_proto_eth_service_beacon_chain_service_proto_goTypes = []interface{}{ - (*empty.Empty)(nil), // 0: google.protobuf.Empty - (*v1.StateRequest)(nil), // 1: ethereum.eth.v1.StateRequest - (*v1.StateValidatorsRequest)(nil), // 2: ethereum.eth.v1.StateValidatorsRequest - (*v1.StateValidatorRequest)(nil), // 3: ethereum.eth.v1.StateValidatorRequest - (*v1.ValidatorBalancesRequest)(nil), // 4: ethereum.eth.v1.ValidatorBalancesRequest - (*v1.StateCommitteesRequest)(nil), // 5: ethereum.eth.v1.StateCommitteesRequest - (*v2.StateSyncCommitteesRequest)(nil), // 6: ethereum.eth.v2.StateSyncCommitteesRequest - (*v2.RandaoRequest)(nil), // 7: ethereum.eth.v2.RandaoRequest - (*v1.BlockHeadersRequest)(nil), // 8: ethereum.eth.v1.BlockHeadersRequest - (*v1.BlockRequest)(nil), // 9: ethereum.eth.v1.BlockRequest - (*v2.SignedBeaconBlockContainer)(nil), // 10: ethereum.eth.v2.SignedBeaconBlockContainer - (*v2.SSZContainer)(nil), // 11: ethereum.eth.v2.SSZContainer - (*v2.SignedBlindedBeaconBlockContainer)(nil), // 12: ethereum.eth.v2.SignedBlindedBeaconBlockContainer - (*v2.BlockRequestV2)(nil), // 13: ethereum.eth.v2.BlockRequestV2 - (*v1.AttestationsPoolRequest)(nil), // 14: ethereum.eth.v1.AttestationsPoolRequest - (*v1.SubmitAttestationsRequest)(nil), // 15: ethereum.eth.v1.SubmitAttestationsRequest - (*v1.AttesterSlashing)(nil), // 16: ethereum.eth.v1.AttesterSlashing - (*v1.ProposerSlashing)(nil), // 17: ethereum.eth.v1.ProposerSlashing - (*v1.SignedVoluntaryExit)(nil), // 18: ethereum.eth.v1.SignedVoluntaryExit - (*v2.SubmitBLSToExecutionChangesRequest)(nil), // 19: ethereum.eth.v2.SubmitBLSToExecutionChangesRequest - (*v2.SubmitPoolSyncCommitteeSignatures)(nil), // 20: ethereum.eth.v2.SubmitPoolSyncCommitteeSignatures - (*v1.GenesisResponse)(nil), // 21: ethereum.eth.v1.GenesisResponse - (*v1.WeakSubjectivityResponse)(nil), // 22: ethereum.eth.v1.WeakSubjectivityResponse - (*v1.StateRootResponse)(nil), // 23: ethereum.eth.v1.StateRootResponse - (*v1.StateForkResponse)(nil), // 24: ethereum.eth.v1.StateForkResponse - (*v1.StateFinalityCheckpointResponse)(nil), // 25: ethereum.eth.v1.StateFinalityCheckpointResponse - (*v1.StateValidatorsResponse)(nil), // 26: ethereum.eth.v1.StateValidatorsResponse - (*v1.StateValidatorResponse)(nil), // 27: ethereum.eth.v1.StateValidatorResponse - (*v1.ValidatorBalancesResponse)(nil), // 28: ethereum.eth.v1.ValidatorBalancesResponse - (*v1.StateCommitteesResponse)(nil), // 29: ethereum.eth.v1.StateCommitteesResponse - (*v2.StateSyncCommitteesResponse)(nil), // 30: ethereum.eth.v2.StateSyncCommitteesResponse - (*v2.RandaoResponse)(nil), // 31: ethereum.eth.v2.RandaoResponse - (*v1.BlockHeadersResponse)(nil), // 32: ethereum.eth.v1.BlockHeadersResponse - (*v1.BlockHeaderResponse)(nil), // 33: ethereum.eth.v1.BlockHeaderResponse - (*v1.BlockRootResponse)(nil), // 34: ethereum.eth.v1.BlockRootResponse - (*v1.BlockResponse)(nil), // 35: ethereum.eth.v1.BlockResponse - (*v1.BlockSSZResponse)(nil), // 36: ethereum.eth.v1.BlockSSZResponse - (*v2.BlockResponseV2)(nil), // 37: ethereum.eth.v2.BlockResponseV2 - (*v2.BlindedBlockResponse)(nil), // 38: ethereum.eth.v2.BlindedBlockResponse - (*v1.BlockAttestationsResponse)(nil), // 39: ethereum.eth.v1.BlockAttestationsResponse - (*v1.AttestationsPoolResponse)(nil), // 40: ethereum.eth.v1.AttestationsPoolResponse - (*v1.AttesterSlashingsPoolResponse)(nil), // 41: ethereum.eth.v1.AttesterSlashingsPoolResponse - (*v1.ProposerSlashingPoolResponse)(nil), // 42: ethereum.eth.v1.ProposerSlashingPoolResponse - (*v1.VoluntaryExitsPoolResponse)(nil), // 43: ethereum.eth.v1.VoluntaryExitsPoolResponse - (*v2.BLSToExecutionChangesPoolResponse)(nil), // 44: ethereum.eth.v2.BLSToExecutionChangesPoolResponse - (*v1.ForkScheduleResponse)(nil), // 45: ethereum.eth.v1.ForkScheduleResponse - (*v1.SpecResponse)(nil), // 46: ethereum.eth.v1.SpecResponse - (*v1.DepositContractResponse)(nil), // 47: ethereum.eth.v1.DepositContractResponse + (*empty.Empty)(nil), // 0: google.protobuf.Empty + (*v1.StateRequest)(nil), // 1: ethereum.eth.v1.StateRequest + (*v1.StateValidatorsRequest)(nil), // 2: ethereum.eth.v1.StateValidatorsRequest + (*v1.StateValidatorRequest)(nil), // 3: ethereum.eth.v1.StateValidatorRequest + (*v1.ValidatorBalancesRequest)(nil), // 4: ethereum.eth.v1.ValidatorBalancesRequest + (*v1.StateCommitteesRequest)(nil), // 5: ethereum.eth.v1.StateCommitteesRequest + (*v2.StateSyncCommitteesRequest)(nil), // 6: ethereum.eth.v2.StateSyncCommitteesRequest + (*v2.RandaoRequest)(nil), // 7: ethereum.eth.v2.RandaoRequest + (*v1.BlockHeadersRequest)(nil), // 8: ethereum.eth.v1.BlockHeadersRequest + (*v1.BlockRequest)(nil), // 9: ethereum.eth.v1.BlockRequest + (*v2.SignedBeaconBlockContainer)(nil), // 10: ethereum.eth.v2.SignedBeaconBlockContainer + (*v2.SSZContainer)(nil), // 11: ethereum.eth.v2.SSZContainer + (*v2.SignedBlindedBeaconBlockContainer)(nil), // 12: ethereum.eth.v2.SignedBlindedBeaconBlockContainer + (*v2.BlockRequestV2)(nil), // 13: ethereum.eth.v2.BlockRequestV2 + (*v1.AttestationsPoolRequest)(nil), // 14: ethereum.eth.v1.AttestationsPoolRequest + (*v1.SubmitAttestationsRequest)(nil), // 15: ethereum.eth.v1.SubmitAttestationsRequest + (*v1.AttesterSlashing)(nil), // 16: ethereum.eth.v1.AttesterSlashing + (*v1.ProposerSlashing)(nil), // 17: ethereum.eth.v1.ProposerSlashing + (*v1.SignedVoluntaryExit)(nil), // 18: ethereum.eth.v1.SignedVoluntaryExit + (*v2.SubmitBLSToExecutionChangesRequest)(nil), // 19: ethereum.eth.v2.SubmitBLSToExecutionChangesRequest + (*v2.SubmitPoolSyncCommitteeSignatures)(nil), // 20: ethereum.eth.v2.SubmitPoolSyncCommitteeSignatures + (*v2.LightClientBootstrapRequest)(nil), // 21: ethereum.eth.v2.LightClientBootstrapRequest + (*v2.LightClientUpdatesByRangeRequest)(nil), // 22: ethereum.eth.v2.LightClientUpdatesByRangeRequest + (*v1.GenesisResponse)(nil), // 23: ethereum.eth.v1.GenesisResponse + (*v1.WeakSubjectivityResponse)(nil), // 24: ethereum.eth.v1.WeakSubjectivityResponse + (*v1.StateRootResponse)(nil), // 25: ethereum.eth.v1.StateRootResponse + (*v1.StateForkResponse)(nil), // 26: ethereum.eth.v1.StateForkResponse + (*v1.StateFinalityCheckpointResponse)(nil), // 27: ethereum.eth.v1.StateFinalityCheckpointResponse + (*v1.StateValidatorsResponse)(nil), // 28: ethereum.eth.v1.StateValidatorsResponse + (*v1.StateValidatorResponse)(nil), // 29: ethereum.eth.v1.StateValidatorResponse + (*v1.ValidatorBalancesResponse)(nil), // 30: ethereum.eth.v1.ValidatorBalancesResponse + (*v1.StateCommitteesResponse)(nil), // 31: ethereum.eth.v1.StateCommitteesResponse + (*v2.StateSyncCommitteesResponse)(nil), // 32: ethereum.eth.v2.StateSyncCommitteesResponse + (*v2.RandaoResponse)(nil), // 33: ethereum.eth.v2.RandaoResponse + (*v1.BlockHeadersResponse)(nil), // 34: ethereum.eth.v1.BlockHeadersResponse + (*v1.BlockHeaderResponse)(nil), // 35: ethereum.eth.v1.BlockHeaderResponse + (*v1.BlockRootResponse)(nil), // 36: ethereum.eth.v1.BlockRootResponse + (*v1.BlockResponse)(nil), // 37: ethereum.eth.v1.BlockResponse + (*v1.BlockSSZResponse)(nil), // 38: ethereum.eth.v1.BlockSSZResponse + (*v2.BlockResponseV2)(nil), // 39: ethereum.eth.v2.BlockResponseV2 + (*v2.BlindedBlockResponse)(nil), // 40: ethereum.eth.v2.BlindedBlockResponse + (*v1.BlockAttestationsResponse)(nil), // 41: ethereum.eth.v1.BlockAttestationsResponse + (*v1.AttestationsPoolResponse)(nil), // 42: ethereum.eth.v1.AttestationsPoolResponse + (*v1.AttesterSlashingsPoolResponse)(nil), // 43: ethereum.eth.v1.AttesterSlashingsPoolResponse + (*v1.ProposerSlashingPoolResponse)(nil), // 44: ethereum.eth.v1.ProposerSlashingPoolResponse + (*v1.VoluntaryExitsPoolResponse)(nil), // 45: ethereum.eth.v1.VoluntaryExitsPoolResponse + (*v2.BLSToExecutionChangesPoolResponse)(nil), // 46: ethereum.eth.v2.BLSToExecutionChangesPoolResponse + (*v1.ForkScheduleResponse)(nil), // 47: ethereum.eth.v1.ForkScheduleResponse + (*v1.SpecResponse)(nil), // 48: ethereum.eth.v1.SpecResponse + (*v1.DepositContractResponse)(nil), // 49: ethereum.eth.v1.DepositContractResponse + (*v2.LightClientBootstrapResponse)(nil), // 50: ethereum.eth.v2.LightClientBootstrapResponse + (*v2.LightClientUpdatesByRangeResponse)(nil), // 51: ethereum.eth.v2.LightClientUpdatesByRangeResponse + (*v2.LightClientFinalityUpdateResponse)(nil), // 52: ethereum.eth.v2.LightClientFinalityUpdateResponse + (*v2.LightClientOptimisticUpdateResponse)(nil), // 53: ethereum.eth.v2.LightClientOptimisticUpdateResponse } var file_proto_eth_service_beacon_chain_service_proto_depIdxs = []int32{ 0, // 0: ethereum.eth.service.BeaconChain.GetGenesis:input_type -> google.protobuf.Empty @@ -523,47 +576,55 @@ var file_proto_eth_service_beacon_chain_service_proto_depIdxs = []int32{ 0, // 36: ethereum.eth.service.BeaconChain.GetForkSchedule:input_type -> google.protobuf.Empty 0, // 37: ethereum.eth.service.BeaconChain.GetSpec:input_type -> google.protobuf.Empty 0, // 38: ethereum.eth.service.BeaconChain.GetDepositContract:input_type -> google.protobuf.Empty - 21, // 39: ethereum.eth.service.BeaconChain.GetGenesis:output_type -> ethereum.eth.v1.GenesisResponse - 22, // 40: ethereum.eth.service.BeaconChain.GetWeakSubjectivity:output_type -> ethereum.eth.v1.WeakSubjectivityResponse - 23, // 41: ethereum.eth.service.BeaconChain.GetStateRoot:output_type -> ethereum.eth.v1.StateRootResponse - 24, // 42: ethereum.eth.service.BeaconChain.GetStateFork:output_type -> ethereum.eth.v1.StateForkResponse - 25, // 43: ethereum.eth.service.BeaconChain.GetFinalityCheckpoints:output_type -> ethereum.eth.v1.StateFinalityCheckpointResponse - 26, // 44: ethereum.eth.service.BeaconChain.ListValidators:output_type -> ethereum.eth.v1.StateValidatorsResponse - 27, // 45: ethereum.eth.service.BeaconChain.GetValidator:output_type -> ethereum.eth.v1.StateValidatorResponse - 28, // 46: ethereum.eth.service.BeaconChain.ListValidatorBalances:output_type -> ethereum.eth.v1.ValidatorBalancesResponse - 29, // 47: ethereum.eth.service.BeaconChain.ListCommittees:output_type -> ethereum.eth.v1.StateCommitteesResponse - 30, // 48: ethereum.eth.service.BeaconChain.ListSyncCommittees:output_type -> ethereum.eth.v2.StateSyncCommitteesResponse - 31, // 49: ethereum.eth.service.BeaconChain.GetRandao:output_type -> ethereum.eth.v2.RandaoResponse - 32, // 50: ethereum.eth.service.BeaconChain.ListBlockHeaders:output_type -> ethereum.eth.v1.BlockHeadersResponse - 33, // 51: ethereum.eth.service.BeaconChain.GetBlockHeader:output_type -> ethereum.eth.v1.BlockHeaderResponse - 0, // 52: ethereum.eth.service.BeaconChain.SubmitBlock:output_type -> google.protobuf.Empty - 0, // 53: ethereum.eth.service.BeaconChain.SubmitBlockSSZ:output_type -> google.protobuf.Empty - 0, // 54: ethereum.eth.service.BeaconChain.SubmitBlindedBlock:output_type -> google.protobuf.Empty - 0, // 55: ethereum.eth.service.BeaconChain.SubmitBlindedBlockSSZ:output_type -> google.protobuf.Empty - 34, // 56: ethereum.eth.service.BeaconChain.GetBlockRoot:output_type -> ethereum.eth.v1.BlockRootResponse - 35, // 57: ethereum.eth.service.BeaconChain.GetBlock:output_type -> ethereum.eth.v1.BlockResponse - 36, // 58: ethereum.eth.service.BeaconChain.GetBlockSSZ:output_type -> ethereum.eth.v1.BlockSSZResponse - 37, // 59: ethereum.eth.service.BeaconChain.GetBlockV2:output_type -> ethereum.eth.v2.BlockResponseV2 - 38, // 60: ethereum.eth.service.BeaconChain.GetBlindedBlock:output_type -> ethereum.eth.v2.BlindedBlockResponse - 11, // 61: ethereum.eth.service.BeaconChain.GetBlindedBlockSSZ:output_type -> ethereum.eth.v2.SSZContainer - 11, // 62: ethereum.eth.service.BeaconChain.GetBlockSSZV2:output_type -> ethereum.eth.v2.SSZContainer - 39, // 63: ethereum.eth.service.BeaconChain.ListBlockAttestations:output_type -> ethereum.eth.v1.BlockAttestationsResponse - 40, // 64: ethereum.eth.service.BeaconChain.ListPoolAttestations:output_type -> ethereum.eth.v1.AttestationsPoolResponse - 0, // 65: ethereum.eth.service.BeaconChain.SubmitAttestations:output_type -> google.protobuf.Empty - 41, // 66: ethereum.eth.service.BeaconChain.ListPoolAttesterSlashings:output_type -> ethereum.eth.v1.AttesterSlashingsPoolResponse - 0, // 67: ethereum.eth.service.BeaconChain.SubmitAttesterSlashing:output_type -> google.protobuf.Empty - 42, // 68: ethereum.eth.service.BeaconChain.ListPoolProposerSlashings:output_type -> ethereum.eth.v1.ProposerSlashingPoolResponse - 0, // 69: ethereum.eth.service.BeaconChain.SubmitProposerSlashing:output_type -> google.protobuf.Empty - 43, // 70: ethereum.eth.service.BeaconChain.ListPoolVoluntaryExits:output_type -> ethereum.eth.v1.VoluntaryExitsPoolResponse - 0, // 71: ethereum.eth.service.BeaconChain.SubmitVoluntaryExit:output_type -> google.protobuf.Empty - 0, // 72: ethereum.eth.service.BeaconChain.SubmitSignedBLSToExecutionChanges:output_type -> google.protobuf.Empty - 0, // 73: ethereum.eth.service.BeaconChain.SubmitPoolSyncCommitteeSignatures:output_type -> google.protobuf.Empty - 44, // 74: ethereum.eth.service.BeaconChain.ListBLSToExecutionChanges:output_type -> ethereum.eth.v2.BLSToExecutionChangesPoolResponse - 45, // 75: ethereum.eth.service.BeaconChain.GetForkSchedule:output_type -> ethereum.eth.v1.ForkScheduleResponse - 46, // 76: ethereum.eth.service.BeaconChain.GetSpec:output_type -> ethereum.eth.v1.SpecResponse - 47, // 77: ethereum.eth.service.BeaconChain.GetDepositContract:output_type -> ethereum.eth.v1.DepositContractResponse - 39, // [39:78] is the sub-list for method output_type - 0, // [0:39] is the sub-list for method input_type + 21, // 39: ethereum.eth.service.BeaconChain.GetLightClientBootstrap:input_type -> ethereum.eth.v2.LightClientBootstrapRequest + 22, // 40: ethereum.eth.service.BeaconChain.GetLightClientUpdatesByRange:input_type -> ethereum.eth.v2.LightClientUpdatesByRangeRequest + 0, // 41: ethereum.eth.service.BeaconChain.GetLightClientFinalityUpdate:input_type -> google.protobuf.Empty + 0, // 42: ethereum.eth.service.BeaconChain.GetLightClientOptimisticUpdate:input_type -> google.protobuf.Empty + 23, // 43: ethereum.eth.service.BeaconChain.GetGenesis:output_type -> ethereum.eth.v1.GenesisResponse + 24, // 44: ethereum.eth.service.BeaconChain.GetWeakSubjectivity:output_type -> ethereum.eth.v1.WeakSubjectivityResponse + 25, // 45: ethereum.eth.service.BeaconChain.GetStateRoot:output_type -> ethereum.eth.v1.StateRootResponse + 26, // 46: ethereum.eth.service.BeaconChain.GetStateFork:output_type -> ethereum.eth.v1.StateForkResponse + 27, // 47: ethereum.eth.service.BeaconChain.GetFinalityCheckpoints:output_type -> ethereum.eth.v1.StateFinalityCheckpointResponse + 28, // 48: ethereum.eth.service.BeaconChain.ListValidators:output_type -> ethereum.eth.v1.StateValidatorsResponse + 29, // 49: ethereum.eth.service.BeaconChain.GetValidator:output_type -> ethereum.eth.v1.StateValidatorResponse + 30, // 50: ethereum.eth.service.BeaconChain.ListValidatorBalances:output_type -> ethereum.eth.v1.ValidatorBalancesResponse + 31, // 51: ethereum.eth.service.BeaconChain.ListCommittees:output_type -> ethereum.eth.v1.StateCommitteesResponse + 32, // 52: ethereum.eth.service.BeaconChain.ListSyncCommittees:output_type -> ethereum.eth.v2.StateSyncCommitteesResponse + 33, // 53: ethereum.eth.service.BeaconChain.GetRandao:output_type -> ethereum.eth.v2.RandaoResponse + 34, // 54: ethereum.eth.service.BeaconChain.ListBlockHeaders:output_type -> ethereum.eth.v1.BlockHeadersResponse + 35, // 55: ethereum.eth.service.BeaconChain.GetBlockHeader:output_type -> ethereum.eth.v1.BlockHeaderResponse + 0, // 56: ethereum.eth.service.BeaconChain.SubmitBlock:output_type -> google.protobuf.Empty + 0, // 57: ethereum.eth.service.BeaconChain.SubmitBlockSSZ:output_type -> google.protobuf.Empty + 0, // 58: ethereum.eth.service.BeaconChain.SubmitBlindedBlock:output_type -> google.protobuf.Empty + 0, // 59: ethereum.eth.service.BeaconChain.SubmitBlindedBlockSSZ:output_type -> google.protobuf.Empty + 36, // 60: ethereum.eth.service.BeaconChain.GetBlockRoot:output_type -> ethereum.eth.v1.BlockRootResponse + 37, // 61: ethereum.eth.service.BeaconChain.GetBlock:output_type -> ethereum.eth.v1.BlockResponse + 38, // 62: ethereum.eth.service.BeaconChain.GetBlockSSZ:output_type -> ethereum.eth.v1.BlockSSZResponse + 39, // 63: ethereum.eth.service.BeaconChain.GetBlockV2:output_type -> ethereum.eth.v2.BlockResponseV2 + 40, // 64: ethereum.eth.service.BeaconChain.GetBlindedBlock:output_type -> ethereum.eth.v2.BlindedBlockResponse + 11, // 65: ethereum.eth.service.BeaconChain.GetBlindedBlockSSZ:output_type -> ethereum.eth.v2.SSZContainer + 11, // 66: ethereum.eth.service.BeaconChain.GetBlockSSZV2:output_type -> ethereum.eth.v2.SSZContainer + 41, // 67: ethereum.eth.service.BeaconChain.ListBlockAttestations:output_type -> ethereum.eth.v1.BlockAttestationsResponse + 42, // 68: ethereum.eth.service.BeaconChain.ListPoolAttestations:output_type -> ethereum.eth.v1.AttestationsPoolResponse + 0, // 69: ethereum.eth.service.BeaconChain.SubmitAttestations:output_type -> google.protobuf.Empty + 43, // 70: ethereum.eth.service.BeaconChain.ListPoolAttesterSlashings:output_type -> ethereum.eth.v1.AttesterSlashingsPoolResponse + 0, // 71: ethereum.eth.service.BeaconChain.SubmitAttesterSlashing:output_type -> google.protobuf.Empty + 44, // 72: ethereum.eth.service.BeaconChain.ListPoolProposerSlashings:output_type -> ethereum.eth.v1.ProposerSlashingPoolResponse + 0, // 73: ethereum.eth.service.BeaconChain.SubmitProposerSlashing:output_type -> google.protobuf.Empty + 45, // 74: ethereum.eth.service.BeaconChain.ListPoolVoluntaryExits:output_type -> ethereum.eth.v1.VoluntaryExitsPoolResponse + 0, // 75: ethereum.eth.service.BeaconChain.SubmitVoluntaryExit:output_type -> google.protobuf.Empty + 0, // 76: ethereum.eth.service.BeaconChain.SubmitSignedBLSToExecutionChanges:output_type -> google.protobuf.Empty + 0, // 77: ethereum.eth.service.BeaconChain.SubmitPoolSyncCommitteeSignatures:output_type -> google.protobuf.Empty + 46, // 78: ethereum.eth.service.BeaconChain.ListBLSToExecutionChanges:output_type -> ethereum.eth.v2.BLSToExecutionChangesPoolResponse + 47, // 79: ethereum.eth.service.BeaconChain.GetForkSchedule:output_type -> ethereum.eth.v1.ForkScheduleResponse + 48, // 80: ethereum.eth.service.BeaconChain.GetSpec:output_type -> ethereum.eth.v1.SpecResponse + 49, // 81: ethereum.eth.service.BeaconChain.GetDepositContract:output_type -> ethereum.eth.v1.DepositContractResponse + 50, // 82: ethereum.eth.service.BeaconChain.GetLightClientBootstrap:output_type -> ethereum.eth.v2.LightClientBootstrapResponse + 51, // 83: ethereum.eth.service.BeaconChain.GetLightClientUpdatesByRange:output_type -> ethereum.eth.v2.LightClientUpdatesByRangeResponse + 52, // 84: ethereum.eth.service.BeaconChain.GetLightClientFinalityUpdate:output_type -> ethereum.eth.v2.LightClientFinalityUpdateResponse + 53, // 85: ethereum.eth.service.BeaconChain.GetLightClientOptimisticUpdate:output_type -> ethereum.eth.v2.LightClientOptimisticUpdateResponse + 43, // [43:86] is the sub-list for method output_type + 0, // [0:43] is the sub-list for method input_type 0, // [0:0] is the sub-list for extension type_name 0, // [0:0] is the sub-list for extension extendee 0, // [0:0] is the sub-list for field type_name @@ -647,6 +708,10 @@ type BeaconChainClient interface { GetForkSchedule(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*v1.ForkScheduleResponse, error) GetSpec(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*v1.SpecResponse, error) GetDepositContract(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*v1.DepositContractResponse, error) + GetLightClientBootstrap(ctx context.Context, in *v2.LightClientBootstrapRequest, opts ...grpc.CallOption) (*v2.LightClientBootstrapResponse, error) + GetLightClientUpdatesByRange(ctx context.Context, in *v2.LightClientUpdatesByRangeRequest, opts ...grpc.CallOption) (*v2.LightClientUpdatesByRangeResponse, error) + GetLightClientFinalityUpdate(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*v2.LightClientFinalityUpdateResponse, error) + GetLightClientOptimisticUpdate(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*v2.LightClientOptimisticUpdateResponse, error) } type beaconChainClient struct { @@ -1011,6 +1076,42 @@ func (c *beaconChainClient) GetDepositContract(ctx context.Context, in *empty.Em return out, nil } +func (c *beaconChainClient) GetLightClientBootstrap(ctx context.Context, in *v2.LightClientBootstrapRequest, opts ...grpc.CallOption) (*v2.LightClientBootstrapResponse, error) { + out := new(v2.LightClientBootstrapResponse) + err := c.cc.Invoke(ctx, "/ethereum.eth.service.BeaconChain/GetLightClientBootstrap", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *beaconChainClient) GetLightClientUpdatesByRange(ctx context.Context, in *v2.LightClientUpdatesByRangeRequest, opts ...grpc.CallOption) (*v2.LightClientUpdatesByRangeResponse, error) { + out := new(v2.LightClientUpdatesByRangeResponse) + err := c.cc.Invoke(ctx, "/ethereum.eth.service.BeaconChain/GetLightClientUpdatesByRange", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *beaconChainClient) GetLightClientFinalityUpdate(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*v2.LightClientFinalityUpdateResponse, error) { + out := new(v2.LightClientFinalityUpdateResponse) + err := c.cc.Invoke(ctx, "/ethereum.eth.service.BeaconChain/GetLightClientFinalityUpdate", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *beaconChainClient) GetLightClientOptimisticUpdate(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*v2.LightClientOptimisticUpdateResponse, error) { + out := new(v2.LightClientOptimisticUpdateResponse) + err := c.cc.Invoke(ctx, "/ethereum.eth.service.BeaconChain/GetLightClientOptimisticUpdate", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // BeaconChainServer is the server API for BeaconChain service. type BeaconChainServer interface { GetGenesis(context.Context, *empty.Empty) (*v1.GenesisResponse, error) @@ -1055,6 +1156,10 @@ type BeaconChainServer interface { GetForkSchedule(context.Context, *empty.Empty) (*v1.ForkScheduleResponse, error) GetSpec(context.Context, *empty.Empty) (*v1.SpecResponse, error) GetDepositContract(context.Context, *empty.Empty) (*v1.DepositContractResponse, error) + GetLightClientBootstrap(context.Context, *v2.LightClientBootstrapRequest) (*v2.LightClientBootstrapResponse, error) + GetLightClientUpdatesByRange(context.Context, *v2.LightClientUpdatesByRangeRequest) (*v2.LightClientUpdatesByRangeResponse, error) + GetLightClientFinalityUpdate(context.Context, *empty.Empty) (*v2.LightClientFinalityUpdateResponse, error) + GetLightClientOptimisticUpdate(context.Context, *empty.Empty) (*v2.LightClientOptimisticUpdateResponse, error) } // UnimplementedBeaconChainServer can be embedded to have forward compatible implementations. @@ -1178,6 +1283,18 @@ func (*UnimplementedBeaconChainServer) GetSpec(context.Context, *empty.Empty) (* func (*UnimplementedBeaconChainServer) GetDepositContract(context.Context, *empty.Empty) (*v1.DepositContractResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetDepositContract not implemented") } +func (*UnimplementedBeaconChainServer) GetLightClientBootstrap(context.Context, *v2.LightClientBootstrapRequest) (*v2.LightClientBootstrapResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetLightClientBootstrap not implemented") +} +func (*UnimplementedBeaconChainServer) GetLightClientUpdatesByRange(context.Context, *v2.LightClientUpdatesByRangeRequest) (*v2.LightClientUpdatesByRangeResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetLightClientUpdatesByRange not implemented") +} +func (*UnimplementedBeaconChainServer) GetLightClientFinalityUpdate(context.Context, *empty.Empty) (*v2.LightClientFinalityUpdateResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetLightClientFinalityUpdate not implemented") +} +func (*UnimplementedBeaconChainServer) GetLightClientOptimisticUpdate(context.Context, *empty.Empty) (*v2.LightClientOptimisticUpdateResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetLightClientOptimisticUpdate not implemented") +} func RegisterBeaconChainServer(s *grpc.Server, srv BeaconChainServer) { s.RegisterService(&_BeaconChain_serviceDesc, srv) @@ -1885,6 +2002,78 @@ func _BeaconChain_GetDepositContract_Handler(srv interface{}, ctx context.Contex return interceptor(ctx, in, info, handler) } +func _BeaconChain_GetLightClientBootstrap_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(v2.LightClientBootstrapRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(BeaconChainServer).GetLightClientBootstrap(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/ethereum.eth.service.BeaconChain/GetLightClientBootstrap", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(BeaconChainServer).GetLightClientBootstrap(ctx, req.(*v2.LightClientBootstrapRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _BeaconChain_GetLightClientUpdatesByRange_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(v2.LightClientUpdatesByRangeRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(BeaconChainServer).GetLightClientUpdatesByRange(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/ethereum.eth.service.BeaconChain/GetLightClientUpdatesByRange", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(BeaconChainServer).GetLightClientUpdatesByRange(ctx, req.(*v2.LightClientUpdatesByRangeRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _BeaconChain_GetLightClientFinalityUpdate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(empty.Empty) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(BeaconChainServer).GetLightClientFinalityUpdate(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/ethereum.eth.service.BeaconChain/GetLightClientFinalityUpdate", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(BeaconChainServer).GetLightClientFinalityUpdate(ctx, req.(*empty.Empty)) + } + return interceptor(ctx, in, info, handler) +} + +func _BeaconChain_GetLightClientOptimisticUpdate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(empty.Empty) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(BeaconChainServer).GetLightClientOptimisticUpdate(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/ethereum.eth.service.BeaconChain/GetLightClientOptimisticUpdate", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(BeaconChainServer).GetLightClientOptimisticUpdate(ctx, req.(*empty.Empty)) + } + return interceptor(ctx, in, info, handler) +} + var _BeaconChain_serviceDesc = grpc.ServiceDesc{ ServiceName: "ethereum.eth.service.BeaconChain", HandlerType: (*BeaconChainServer)(nil), @@ -2045,6 +2234,22 @@ var _BeaconChain_serviceDesc = grpc.ServiceDesc{ MethodName: "GetDepositContract", Handler: _BeaconChain_GetDepositContract_Handler, }, + { + MethodName: "GetLightClientBootstrap", + Handler: _BeaconChain_GetLightClientBootstrap_Handler, + }, + { + MethodName: "GetLightClientUpdatesByRange", + Handler: _BeaconChain_GetLightClientUpdatesByRange_Handler, + }, + { + MethodName: "GetLightClientFinalityUpdate", + Handler: _BeaconChain_GetLightClientFinalityUpdate_Handler, + }, + { + MethodName: "GetLightClientOptimisticUpdate", + Handler: _BeaconChain_GetLightClientOptimisticUpdate_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "proto/eth/service/beacon_chain_service.proto", diff --git a/proto/eth/service/beacon_chain_service.pb.gw.go b/proto/eth/service/beacon_chain_service.pb.gw.go index d6c038665b84..91af6c44af1a 100755 --- a/proto/eth/service/beacon_chain_service.pb.gw.go +++ b/proto/eth/service/beacon_chain_service.pb.gw.go @@ -10,9 +10,6 @@ package service import ( "context" - "io" - "net/http" - "github.com/golang/protobuf/ptypes/empty" emptypb "github.com/golang/protobuf/ptypes/empty" "github.com/grpc-ecosystem/grpc-gateway/v2/runtime" @@ -26,6 +23,8 @@ import ( "google.golang.org/grpc/metadata" "google.golang.org/grpc/status" "google.golang.org/protobuf/proto" + "io" + "net/http" ) // Suppress "imported and not used" errors @@ -1697,6 +1696,132 @@ func local_request_BeaconChain_GetDepositContract_0(ctx context.Context, marshal } +func request_BeaconChain_GetLightClientBootstrap_0(ctx context.Context, marshaler runtime.Marshaler, client BeaconChainClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq eth.LightClientBootstrapRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["block_root"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "block_root") + } + + block_root, err := runtime.Bytes(val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "block_root", err) + } + protoReq.BlockRoot = (block_root) + + msg, err := client.GetLightClientBootstrap(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_BeaconChain_GetLightClientBootstrap_0(ctx context.Context, marshaler runtime.Marshaler, server BeaconChainServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq eth.LightClientBootstrapRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["block_root"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "block_root") + } + + block_root, err := runtime.Bytes(val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "block_root", err) + } + protoReq.BlockRoot = (block_root) + + msg, err := server.GetLightClientBootstrap(ctx, &protoReq) + return msg, metadata, err + +} + +var ( + filter_BeaconChain_GetLightClientUpdatesByRange_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} +) + +func request_BeaconChain_GetLightClientUpdatesByRange_0(ctx context.Context, marshaler runtime.Marshaler, client BeaconChainClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq eth.LightClientUpdatesByRangeRequest + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_BeaconChain_GetLightClientUpdatesByRange_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.GetLightClientUpdatesByRange(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_BeaconChain_GetLightClientUpdatesByRange_0(ctx context.Context, marshaler runtime.Marshaler, server BeaconChainServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq eth.LightClientUpdatesByRangeRequest + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_BeaconChain_GetLightClientUpdatesByRange_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.GetLightClientUpdatesByRange(ctx, &protoReq) + return msg, metadata, err + +} + +func request_BeaconChain_GetLightClientFinalityUpdate_0(ctx context.Context, marshaler runtime.Marshaler, client BeaconChainClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq emptypb.Empty + var metadata runtime.ServerMetadata + + msg, err := client.GetLightClientFinalityUpdate(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_BeaconChain_GetLightClientFinalityUpdate_0(ctx context.Context, marshaler runtime.Marshaler, server BeaconChainServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq emptypb.Empty + var metadata runtime.ServerMetadata + + msg, err := server.GetLightClientFinalityUpdate(ctx, &protoReq) + return msg, metadata, err + +} + +func request_BeaconChain_GetLightClientOptimisticUpdate_0(ctx context.Context, marshaler runtime.Marshaler, client BeaconChainClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq emptypb.Empty + var metadata runtime.ServerMetadata + + msg, err := client.GetLightClientOptimisticUpdate(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_BeaconChain_GetLightClientOptimisticUpdate_0(ctx context.Context, marshaler runtime.Marshaler, server BeaconChainServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq emptypb.Empty + var metadata runtime.ServerMetadata + + msg, err := server.GetLightClientOptimisticUpdate(ctx, &protoReq) + return msg, metadata, err + +} + // RegisterBeaconChainHandlerServer registers the http handlers for service BeaconChain to "mux". // UnaryRPC :call BeaconChainServer directly. // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. @@ -2600,6 +2725,98 @@ func RegisterBeaconChainHandlerServer(ctx context.Context, mux *runtime.ServeMux }) + mux.Handle("GET", pattern_BeaconChain_GetLightClientBootstrap_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/ethereum.eth.service.BeaconChain/GetLightClientBootstrap") + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_BeaconChain_GetLightClientBootstrap_0(rctx, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_BeaconChain_GetLightClientBootstrap_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_BeaconChain_GetLightClientUpdatesByRange_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/ethereum.eth.service.BeaconChain/GetLightClientUpdatesByRange") + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_BeaconChain_GetLightClientUpdatesByRange_0(rctx, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_BeaconChain_GetLightClientUpdatesByRange_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_BeaconChain_GetLightClientFinalityUpdate_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/ethereum.eth.service.BeaconChain/GetLightClientFinalityUpdate") + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_BeaconChain_GetLightClientFinalityUpdate_0(rctx, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_BeaconChain_GetLightClientFinalityUpdate_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_BeaconChain_GetLightClientOptimisticUpdate_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/ethereum.eth.service.BeaconChain/GetLightClientOptimisticUpdate") + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_BeaconChain_GetLightClientOptimisticUpdate_0(rctx, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_BeaconChain_GetLightClientOptimisticUpdate_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + return nil } @@ -3421,6 +3638,86 @@ func RegisterBeaconChainHandlerClient(ctx context.Context, mux *runtime.ServeMux }) + mux.Handle("GET", pattern_BeaconChain_GetLightClientBootstrap_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req, "/ethereum.eth.service.BeaconChain/GetLightClientBootstrap") + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_BeaconChain_GetLightClientBootstrap_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_BeaconChain_GetLightClientBootstrap_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_BeaconChain_GetLightClientUpdatesByRange_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req, "/ethereum.eth.service.BeaconChain/GetLightClientUpdatesByRange") + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_BeaconChain_GetLightClientUpdatesByRange_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_BeaconChain_GetLightClientUpdatesByRange_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_BeaconChain_GetLightClientFinalityUpdate_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req, "/ethereum.eth.service.BeaconChain/GetLightClientFinalityUpdate") + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_BeaconChain_GetLightClientFinalityUpdate_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_BeaconChain_GetLightClientFinalityUpdate_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_BeaconChain_GetLightClientOptimisticUpdate_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req, "/ethereum.eth.service.BeaconChain/GetLightClientOptimisticUpdate") + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_BeaconChain_GetLightClientOptimisticUpdate_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_BeaconChain_GetLightClientOptimisticUpdate_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + return nil } @@ -3502,6 +3799,14 @@ var ( pattern_BeaconChain_GetSpec_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"internal", "eth", "v1", "config", "spec"}, "")) pattern_BeaconChain_GetDepositContract_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"internal", "eth", "v1", "config", "deposit_contract"}, "")) + + pattern_BeaconChain_GetLightClientBootstrap_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 2, 5, 1, 0, 4, 1, 5, 6}, []string{"internal", "eth", "v1", "beacon", "light_client", "bootstrap", "block_root"}, "")) + + pattern_BeaconChain_GetLightClientUpdatesByRange_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 2, 5}, []string{"internal", "eth", "v1", "beacon", "light_client", "updates"}, "")) + + pattern_BeaconChain_GetLightClientFinalityUpdate_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 2, 5}, []string{"internal", "eth", "v1", "beacon", "light_client", "finality_update"}, "")) + + pattern_BeaconChain_GetLightClientOptimisticUpdate_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 2, 5}, []string{"internal", "eth", "v1", "beacon", "light_client", "optimistic_update"}, "")) ) var ( @@ -3582,4 +3887,12 @@ var ( forward_BeaconChain_GetSpec_0 = runtime.ForwardResponseMessage forward_BeaconChain_GetDepositContract_0 = runtime.ForwardResponseMessage + + forward_BeaconChain_GetLightClientBootstrap_0 = runtime.ForwardResponseMessage + + forward_BeaconChain_GetLightClientUpdatesByRange_0 = runtime.ForwardResponseMessage + + forward_BeaconChain_GetLightClientFinalityUpdate_0 = runtime.ForwardResponseMessage + + forward_BeaconChain_GetLightClientOptimisticUpdate_0 = runtime.ForwardResponseMessage ) diff --git a/proto/eth/service/beacon_chain_service.proto b/proto/eth/service/beacon_chain_service.proto index f6d0029b2a97..0348ec9fecc8 100644 --- a/proto/eth/service/beacon_chain_service.proto +++ b/proto/eth/service/beacon_chain_service.proto @@ -21,6 +21,7 @@ import "google/protobuf/empty.proto"; import "proto/eth/v1/beacon_block.proto"; import "proto/eth/v1/beacon_chain.proto"; +import "proto/eth/v2/beacon_lightclient.proto"; import "proto/eth/v2/beacon_block.proto"; import "proto/eth/v2/beacon_chain.proto"; import "proto/eth/v2/beacon_state.proto"; @@ -445,5 +446,41 @@ service BeaconChain { rpc GetDepositContract(google.protobuf.Empty) returns (v1.DepositContractResponse) { option (google.api.http) = {get: "/internal/eth/v1/config/deposit_contract"}; } + + // GetLightClientBootstrap retrieves the LightClientBootstrap structure corresponding to a given post-Altair beacon block root + // + // Spec: https://ethereum.github.io/beacon-APIs/?urls.primaryName=dev#/Beacon/getLightClientBootstrap + rpc GetLightClientBootstrap(v2.LightClientBootstrapRequest) returns (v2.LightClientBootstrapResponse) { + option (google.api.http) = { + get: "/internal/eth/v1/beacon/light_client/bootstrap/{block_root}" + }; + } + + // GetLightClientUpdatesByRange retrieves light client updates based the period range asked. + // + // Spec: https://ethereum.github.io/beacon-APIs/?urls.primaryName=dev#/Beacon/getLightClientUpdatesByRange + rpc GetLightClientUpdatesByRange(v2.LightClientUpdatesByRangeRequest) returns (v2.LightClientUpdatesByRangeResponse) { + option (google.api.http) = { + get: "/internal/eth/v1/beacon/light_client/updates" + }; + } + + // GetLightClientFinalityUpdate retrieves the latest finality update for light client + // + // Spec: https://ethereum.github.io/beacon-APIs/?urls.primaryName=dev#/Beacon/getLightClientFinalityUpdate + rpc GetLightClientFinalityUpdate(google.protobuf.Empty) returns (v2.LightClientFinalityUpdateResponse) { + option (google.api.http) = { + get: "/internal/eth/v1/beacon/light_client/finality_update" + }; + } + + // GetLightClientOptimisticUpdate retrieves the latest finality update for light client + // + // Spec: https://ethereum.github.io/beacon-APIs/?urls.primaryName=dev#/Beacon/getLightClientOptimisticUpdate + rpc GetLightClientOptimisticUpdate(google.protobuf.Empty) returns (v2.LightClientOptimisticUpdateResponse) { + option (google.api.http) = { + get: "/internal/eth/v1/beacon/light_client/optimistic_update" + }; + } } diff --git a/proto/eth/service/beacon_debug_service.pb.go b/proto/eth/service/beacon_debug_service.pb.go index 90115a01ed2a..69c28eb04b8f 100755 --- a/proto/eth/service/beacon_debug_service.pb.go +++ b/proto/eth/service/beacon_debug_service.pb.go @@ -1,15 +1,13 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.30.0 -// protoc v3.15.8 +// protoc v4.23.3 // source: proto/eth/service/beacon_debug_service.proto package service import ( context "context" - reflect "reflect" - _ "github.com/golang/protobuf/protoc-gen-go/descriptor" empty "github.com/golang/protobuf/ptypes/empty" v1 "github.com/prysmaticlabs/prysm/v4/proto/eth/v1" @@ -20,6 +18,7 @@ import ( status "google.golang.org/grpc/status" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" ) const ( diff --git a/proto/eth/service/beacon_debug_service.pb.gw.go b/proto/eth/service/beacon_debug_service.pb.gw.go index 74ed0723dbe7..17dbbd41215a 100755 --- a/proto/eth/service/beacon_debug_service.pb.gw.go +++ b/proto/eth/service/beacon_debug_service.pb.gw.go @@ -10,9 +10,6 @@ package service import ( "context" - "io" - "net/http" - "github.com/golang/protobuf/ptypes/empty" emptypb "github.com/golang/protobuf/ptypes/empty" "github.com/grpc-ecosystem/grpc-gateway/v2/runtime" @@ -26,6 +23,8 @@ import ( "google.golang.org/grpc/metadata" "google.golang.org/grpc/status" "google.golang.org/protobuf/proto" + "io" + "net/http" ) // Suppress "imported and not used" errors diff --git a/proto/eth/service/events_service.pb.go b/proto/eth/service/events_service.pb.go index f85b34a21be1..3f7683447df2 100755 --- a/proto/eth/service/events_service.pb.go +++ b/proto/eth/service/events_service.pb.go @@ -1,15 +1,13 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.30.0 -// protoc v3.15.8 +// protoc v4.23.3 // source: proto/eth/service/events_service.proto package service import ( context "context" - reflect "reflect" - _ "github.com/golang/protobuf/protoc-gen-go/descriptor" gateway "github.com/grpc-ecosystem/grpc-gateway/v2/proto/gateway" v1 "github.com/prysmaticlabs/prysm/v4/proto/eth/v1" @@ -19,6 +17,7 @@ import ( status "google.golang.org/grpc/status" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" ) const ( diff --git a/proto/eth/service/events_service.pb.gw.go b/proto/eth/service/events_service.pb.gw.go index 6c1b7bd0fa69..1a8181888aff 100755 --- a/proto/eth/service/events_service.pb.gw.go +++ b/proto/eth/service/events_service.pb.gw.go @@ -10,9 +10,6 @@ package service import ( "context" - "io" - "net/http" - "github.com/golang/protobuf/ptypes/empty" emptypb "github.com/golang/protobuf/ptypes/empty" "github.com/grpc-ecosystem/grpc-gateway/v2/runtime" @@ -25,6 +22,8 @@ import ( "google.golang.org/grpc/metadata" "google.golang.org/grpc/status" "google.golang.org/protobuf/proto" + "io" + "net/http" ) // Suppress "imported and not used" errors diff --git a/proto/eth/service/key_management.pb.go b/proto/eth/service/key_management.pb.go index ea332d5c3ae4..6d56f4ba72e0 100755 --- a/proto/eth/service/key_management.pb.go +++ b/proto/eth/service/key_management.pb.go @@ -1,26 +1,25 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.30.0 -// protoc v3.15.8 +// protoc v4.23.3 // source: proto/eth/service/key_management.proto package service import ( context "context" - reflect "reflect" - sync "sync" - _ "github.com/golang/protobuf/protoc-gen-go/descriptor" empty "github.com/golang/protobuf/ptypes/empty" - github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" _ "github.com/prysmaticlabs/prysm/v4/proto/eth/ext" + github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" _ "google.golang.org/genproto/googleapis/api/annotations" grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" ) const ( diff --git a/proto/eth/service/key_management.pb.gw.go b/proto/eth/service/key_management.pb.gw.go index cc446408b341..465f51824187 100755 --- a/proto/eth/service/key_management.pb.gw.go +++ b/proto/eth/service/key_management.pb.gw.go @@ -10,9 +10,6 @@ package service import ( "context" - "io" - "net/http" - "github.com/golang/protobuf/ptypes/empty" emptypb "github.com/golang/protobuf/ptypes/empty" "github.com/grpc-ecosystem/grpc-gateway/v2/runtime" @@ -24,6 +21,8 @@ import ( "google.golang.org/grpc/metadata" "google.golang.org/grpc/status" "google.golang.org/protobuf/proto" + "io" + "net/http" ) // Suppress "imported and not used" errors diff --git a/proto/eth/service/node_service.pb.go b/proto/eth/service/node_service.pb.go index 5de655a8b1b2..7ff2570a4eef 100755 --- a/proto/eth/service/node_service.pb.go +++ b/proto/eth/service/node_service.pb.go @@ -1,15 +1,13 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.30.0 -// protoc v3.15.8 +// protoc v4.23.3 // source: proto/eth/service/node_service.proto package service import ( context "context" - reflect "reflect" - _ "github.com/golang/protobuf/protoc-gen-go/descriptor" empty "github.com/golang/protobuf/ptypes/empty" v1 "github.com/prysmaticlabs/prysm/v4/proto/eth/v1" @@ -19,6 +17,7 @@ import ( status "google.golang.org/grpc/status" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" ) const ( diff --git a/proto/eth/service/node_service.pb.gw.go b/proto/eth/service/node_service.pb.gw.go index 860b5cd47436..6aff463c42ed 100755 --- a/proto/eth/service/node_service.pb.gw.go +++ b/proto/eth/service/node_service.pb.gw.go @@ -10,9 +10,6 @@ package service import ( "context" - "io" - "net/http" - "github.com/golang/protobuf/ptypes/empty" emptypb "github.com/golang/protobuf/ptypes/empty" "github.com/grpc-ecosystem/grpc-gateway/v2/runtime" @@ -25,6 +22,8 @@ import ( "google.golang.org/grpc/metadata" "google.golang.org/grpc/status" "google.golang.org/protobuf/proto" + "io" + "net/http" ) // Suppress "imported and not used" errors diff --git a/proto/eth/service/validator_service.pb.go b/proto/eth/service/validator_service.pb.go index b4234622db2a..021e044c0950 100755 --- a/proto/eth/service/validator_service.pb.go +++ b/proto/eth/service/validator_service.pb.go @@ -1,15 +1,13 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.30.0 -// protoc v3.15.8 +// protoc v4.23.3 // source: proto/eth/service/validator_service.proto package service import ( context "context" - reflect "reflect" - _ "github.com/golang/protobuf/protoc-gen-go/descriptor" empty "github.com/golang/protobuf/ptypes/empty" v1 "github.com/prysmaticlabs/prysm/v4/proto/eth/v1" @@ -20,6 +18,7 @@ import ( status "google.golang.org/grpc/status" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" ) const ( diff --git a/proto/eth/service/validator_service.pb.gw.go b/proto/eth/service/validator_service.pb.gw.go index 9bd362f89b40..86438a9c4909 100755 --- a/proto/eth/service/validator_service.pb.gw.go +++ b/proto/eth/service/validator_service.pb.gw.go @@ -10,9 +10,6 @@ package service import ( "context" - "io" - "net/http" - "github.com/golang/protobuf/ptypes/empty" emptypb "github.com/golang/protobuf/ptypes/empty" "github.com/grpc-ecosystem/grpc-gateway/v2/runtime" @@ -26,6 +23,8 @@ import ( "google.golang.org/grpc/metadata" "google.golang.org/grpc/status" "google.golang.org/protobuf/proto" + "io" + "net/http" ) // Suppress "imported and not used" errors diff --git a/proto/eth/v1/attestation.pb.go b/proto/eth/v1/attestation.pb.go index 66cc9c38fd4b..dfa6beb84761 100755 --- a/proto/eth/v1/attestation.pb.go +++ b/proto/eth/v1/attestation.pb.go @@ -1,21 +1,20 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.30.0 -// protoc v3.15.8 +// protoc v4.23.3 // source: proto/eth/v1/attestation.proto package v1 import ( - reflect "reflect" - sync "sync" - _ "github.com/golang/protobuf/protoc-gen-go/descriptor" - github_com_prysmaticlabs_go_bitfield "github.com/prysmaticlabs/go-bitfield" - github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" _ "github.com/prysmaticlabs/prysm/v4/proto/eth/ext" + github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" + github_com_prysmaticlabs_go_bitfield "github.com/prysmaticlabs/go-bitfield" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" ) const ( diff --git a/proto/eth/v1/beacon_block.pb.go b/proto/eth/v1/beacon_block.pb.go index e5bc0d053ec1..f1fb894b1ad2 100755 --- a/proto/eth/v1/beacon_block.pb.go +++ b/proto/eth/v1/beacon_block.pb.go @@ -1,21 +1,20 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.30.0 -// protoc v3.15.8 +// protoc v4.23.3 // source: proto/eth/v1/beacon_block.proto package v1 import ( - reflect "reflect" - sync "sync" - _ "github.com/golang/protobuf/protoc-gen-go/descriptor" + _ "github.com/prysmaticlabs/prysm/v4/proto/eth/ext" github_com_prysmaticlabs_go_bitfield "github.com/prysmaticlabs/go-bitfield" github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" - _ "github.com/prysmaticlabs/prysm/v4/proto/eth/ext" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" ) const ( diff --git a/proto/eth/v1/beacon_chain.pb.go b/proto/eth/v1/beacon_chain.pb.go index 2e339c26ddae..f492ff92739e 100755 --- a/proto/eth/v1/beacon_chain.pb.go +++ b/proto/eth/v1/beacon_chain.pb.go @@ -1,21 +1,20 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.30.0 -// protoc v3.15.8 +// protoc v4.23.3 // source: proto/eth/v1/beacon_chain.proto package v1 import ( - reflect "reflect" - sync "sync" - _ "github.com/golang/protobuf/protoc-gen-go/descriptor" timestamp "github.com/golang/protobuf/ptypes/timestamp" - github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" _ "github.com/prysmaticlabs/prysm/v4/proto/eth/ext" + github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" ) const ( diff --git a/proto/eth/v1/beacon_state.pb.go b/proto/eth/v1/beacon_state.pb.go index ca9ed789c8a8..200534e2d154 100755 --- a/proto/eth/v1/beacon_state.pb.go +++ b/proto/eth/v1/beacon_state.pb.go @@ -1,21 +1,20 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.30.0 -// protoc v3.15.8 +// protoc v4.23.3 // source: proto/eth/v1/beacon_state.proto package v1 import ( - reflect "reflect" - sync "sync" - _ "github.com/golang/protobuf/protoc-gen-go/descriptor" + _ "github.com/prysmaticlabs/prysm/v4/proto/eth/ext" github_com_prysmaticlabs_go_bitfield "github.com/prysmaticlabs/go-bitfield" github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" - _ "github.com/prysmaticlabs/prysm/v4/proto/eth/ext" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" ) const ( diff --git a/proto/eth/v1/events.pb.go b/proto/eth/v1/events.pb.go index 9a4a6e7707ac..f8531c0294dc 100755 --- a/proto/eth/v1/events.pb.go +++ b/proto/eth/v1/events.pb.go @@ -1,21 +1,20 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.30.0 -// protoc v3.15.8 +// protoc v4.23.3 // source: proto/eth/v1/events.proto package v1 import ( - reflect "reflect" - sync "sync" - _ "github.com/golang/protobuf/protoc-gen-go/descriptor" - github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" v1 "github.com/prysmaticlabs/prysm/v4/proto/engine/v1" + github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" _ "github.com/prysmaticlabs/prysm/v4/proto/eth/ext" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" ) const ( diff --git a/proto/eth/v1/node.pb.go b/proto/eth/v1/node.pb.go index 75160585699e..01e873f00f8d 100755 --- a/proto/eth/v1/node.pb.go +++ b/proto/eth/v1/node.pb.go @@ -1,21 +1,20 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.30.0 -// protoc v3.15.8 +// protoc v4.23.3 // source: proto/eth/v1/node.proto package v1 import ( - reflect "reflect" - sync "sync" - _ "github.com/golang/protobuf/protoc-gen-go/descriptor" - github_com_prysmaticlabs_go_bitfield "github.com/prysmaticlabs/go-bitfield" - github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" _ "github.com/prysmaticlabs/prysm/v4/proto/eth/ext" + github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" + github_com_prysmaticlabs_go_bitfield "github.com/prysmaticlabs/go-bitfield" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" ) const ( diff --git a/proto/eth/v1/validator.pb.go b/proto/eth/v1/validator.pb.go index f52fd77604ce..4a2b1cde9818 100755 --- a/proto/eth/v1/validator.pb.go +++ b/proto/eth/v1/validator.pb.go @@ -1,20 +1,19 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.30.0 -// protoc v3.15.8 +// protoc v4.23.3 // source: proto/eth/v1/validator.proto package v1 import ( - reflect "reflect" - sync "sync" - _ "github.com/golang/protobuf/protoc-gen-go/descriptor" - github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" _ "github.com/prysmaticlabs/prysm/v4/proto/eth/ext" + github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" ) const ( diff --git a/proto/eth/v2/BUILD.bazel b/proto/eth/v2/BUILD.bazel index 982827faae2a..15b0c43c44eb 100644 --- a/proto/eth/v2/BUILD.bazel +++ b/proto/eth/v2/BUILD.bazel @@ -46,6 +46,7 @@ ssz_gen_marshal( "SignedBeaconBlockCapella", "SignedBlindedBeaconBlockCapella", "SignedBlsToExecutionChange", + "SyncCommittee", ], ) @@ -92,6 +93,7 @@ go_library( ssz_proto_files( name = "ssz_proto_files", srcs = [ + "beacon_lightclient.proto", "beacon_state.proto", "sync_committee.proto", "validator.proto", diff --git a/proto/eth/v2/beacon_block.pb.go b/proto/eth/v2/beacon_block.pb.go index b42dd61dfea1..c8db1177cb2a 100755 --- a/proto/eth/v2/beacon_block.pb.go +++ b/proto/eth/v2/beacon_block.pb.go @@ -1,21 +1,20 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.30.0 -// protoc v3.15.8 +// protoc v4.23.3 // source: proto/eth/v2/beacon_block.proto package eth import ( - reflect "reflect" - sync "sync" - - github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" v11 "github.com/prysmaticlabs/prysm/v4/proto/engine/v1" + github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" _ "github.com/prysmaticlabs/prysm/v4/proto/eth/ext" v1 "github.com/prysmaticlabs/prysm/v4/proto/eth/v1" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" ) const ( diff --git a/proto/eth/v2/beacon_block.pb.gw.go b/proto/eth/v2/beacon_block.pb.gw.go index cdd03643f0c7..b76fb6098a37 100755 --- a/proto/eth/v2/beacon_block.pb.gw.go +++ b/proto/eth/v2/beacon_block.pb.gw.go @@ -1,4 +1,3 @@ -//go:build ignore // +build ignore -package ignore +package ignore \ No newline at end of file diff --git a/proto/eth/v2/beacon_chain.pb.go b/proto/eth/v2/beacon_chain.pb.go index 5af3487dfbd2..9c2872157230 100755 --- a/proto/eth/v2/beacon_chain.pb.go +++ b/proto/eth/v2/beacon_chain.pb.go @@ -1,17 +1,16 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.30.0 -// protoc v3.15.8 +// protoc v4.23.3 // source: proto/eth/v2/beacon_chain.proto package eth import ( - reflect "reflect" - sync "sync" - protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" ) const ( diff --git a/proto/eth/v2/beacon_lightclient.pb.go b/proto/eth/v2/beacon_lightclient.pb.go new file mode 100755 index 000000000000..bf5a3bebd46a --- /dev/null +++ b/proto/eth/v2/beacon_lightclient.pb.go @@ -0,0 +1,1095 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.30.0 +// protoc v4.23.3 +// source: proto/eth/v2/beacon_lightclient.proto + +package eth + +import ( + _ "github.com/prysmaticlabs/prysm/v4/proto/eth/ext" + github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" + v1 "github.com/prysmaticlabs/prysm/v4/proto/eth/v1" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type LightClientBootstrapRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + BlockRoot []byte `protobuf:"bytes,1,opt,name=block_root,json=blockRoot,proto3" json:"block_root,omitempty" ssz-size:"32"` +} + +func (x *LightClientBootstrapRequest) Reset() { + *x = LightClientBootstrapRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_proto_eth_v2_beacon_lightclient_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LightClientBootstrapRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LightClientBootstrapRequest) ProtoMessage() {} + +func (x *LightClientBootstrapRequest) ProtoReflect() protoreflect.Message { + mi := &file_proto_eth_v2_beacon_lightclient_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LightClientBootstrapRequest.ProtoReflect.Descriptor instead. +func (*LightClientBootstrapRequest) Descriptor() ([]byte, []int) { + return file_proto_eth_v2_beacon_lightclient_proto_rawDescGZIP(), []int{0} +} + +func (x *LightClientBootstrapRequest) GetBlockRoot() []byte { + if x != nil { + return x.BlockRoot + } + return nil +} + +type LightClientBootstrapResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Version Version `protobuf:"varint,1,opt,name=version,proto3,enum=ethereum.eth.v2.Version" json:"version,omitempty"` + Data *LightClientBootstrap `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` +} + +func (x *LightClientBootstrapResponse) Reset() { + *x = LightClientBootstrapResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_proto_eth_v2_beacon_lightclient_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LightClientBootstrapResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LightClientBootstrapResponse) ProtoMessage() {} + +func (x *LightClientBootstrapResponse) ProtoReflect() protoreflect.Message { + mi := &file_proto_eth_v2_beacon_lightclient_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LightClientBootstrapResponse.ProtoReflect.Descriptor instead. +func (*LightClientBootstrapResponse) Descriptor() ([]byte, []int) { + return file_proto_eth_v2_beacon_lightclient_proto_rawDescGZIP(), []int{1} +} + +func (x *LightClientBootstrapResponse) GetVersion() Version { + if x != nil { + return x.Version + } + return Version_PHASE0 +} + +func (x *LightClientBootstrapResponse) GetData() *LightClientBootstrap { + if x != nil { + return x.Data + } + return nil +} + +type LightClientBootstrap struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Header *v1.BeaconBlockHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` + CurrentSyncCommittee *SyncCommittee `protobuf:"bytes,2,opt,name=current_sync_committee,json=currentSyncCommittee,proto3" json:"current_sync_committee,omitempty"` + CurrentSyncCommitteeBranch [][]byte `protobuf:"bytes,3,rep,name=current_sync_committee_branch,json=currentSyncCommitteeBranch,proto3" json:"current_sync_committee_branch,omitempty" ssz-size:"current_sync_committee_branch.depth,32"` +} + +func (x *LightClientBootstrap) Reset() { + *x = LightClientBootstrap{} + if protoimpl.UnsafeEnabled { + mi := &file_proto_eth_v2_beacon_lightclient_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LightClientBootstrap) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LightClientBootstrap) ProtoMessage() {} + +func (x *LightClientBootstrap) ProtoReflect() protoreflect.Message { + mi := &file_proto_eth_v2_beacon_lightclient_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LightClientBootstrap.ProtoReflect.Descriptor instead. +func (*LightClientBootstrap) Descriptor() ([]byte, []int) { + return file_proto_eth_v2_beacon_lightclient_proto_rawDescGZIP(), []int{2} +} + +func (x *LightClientBootstrap) GetHeader() *v1.BeaconBlockHeader { + if x != nil { + return x.Header + } + return nil +} + +func (x *LightClientBootstrap) GetCurrentSyncCommittee() *SyncCommittee { + if x != nil { + return x.CurrentSyncCommittee + } + return nil +} + +func (x *LightClientBootstrap) GetCurrentSyncCommitteeBranch() [][]byte { + if x != nil { + return x.CurrentSyncCommitteeBranch + } + return nil +} + +type LightClientUpdatesByRangeRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + StartPeriod uint64 `protobuf:"varint,1,opt,name=start_period,json=startPeriod,proto3" json:"start_period,omitempty"` + Count uint32 `protobuf:"varint,2,opt,name=count,proto3" json:"count,omitempty"` +} + +func (x *LightClientUpdatesByRangeRequest) Reset() { + *x = LightClientUpdatesByRangeRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_proto_eth_v2_beacon_lightclient_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LightClientUpdatesByRangeRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LightClientUpdatesByRangeRequest) ProtoMessage() {} + +func (x *LightClientUpdatesByRangeRequest) ProtoReflect() protoreflect.Message { + mi := &file_proto_eth_v2_beacon_lightclient_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LightClientUpdatesByRangeRequest.ProtoReflect.Descriptor instead. +func (*LightClientUpdatesByRangeRequest) Descriptor() ([]byte, []int) { + return file_proto_eth_v2_beacon_lightclient_proto_rawDescGZIP(), []int{3} +} + +func (x *LightClientUpdatesByRangeRequest) GetStartPeriod() uint64 { + if x != nil { + return x.StartPeriod + } + return 0 +} + +func (x *LightClientUpdatesByRangeRequest) GetCount() uint32 { + if x != nil { + return x.Count + } + return 0 +} + +type LightClientUpdatesByRangeResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Updates []*LightClientUpdateWithVersion `protobuf:"bytes,1,rep,name=updates,proto3" json:"updates,omitempty"` +} + +func (x *LightClientUpdatesByRangeResponse) Reset() { + *x = LightClientUpdatesByRangeResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_proto_eth_v2_beacon_lightclient_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LightClientUpdatesByRangeResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LightClientUpdatesByRangeResponse) ProtoMessage() {} + +func (x *LightClientUpdatesByRangeResponse) ProtoReflect() protoreflect.Message { + mi := &file_proto_eth_v2_beacon_lightclient_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LightClientUpdatesByRangeResponse.ProtoReflect.Descriptor instead. +func (*LightClientUpdatesByRangeResponse) Descriptor() ([]byte, []int) { + return file_proto_eth_v2_beacon_lightclient_proto_rawDescGZIP(), []int{4} +} + +func (x *LightClientUpdatesByRangeResponse) GetUpdates() []*LightClientUpdateWithVersion { + if x != nil { + return x.Updates + } + return nil +} + +type LightClientUpdateWithVersion struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Version Version `protobuf:"varint,1,opt,name=version,proto3,enum=ethereum.eth.v2.Version" json:"version,omitempty"` + Data *LightClientUpdate `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` +} + +func (x *LightClientUpdateWithVersion) Reset() { + *x = LightClientUpdateWithVersion{} + if protoimpl.UnsafeEnabled { + mi := &file_proto_eth_v2_beacon_lightclient_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LightClientUpdateWithVersion) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LightClientUpdateWithVersion) ProtoMessage() {} + +func (x *LightClientUpdateWithVersion) ProtoReflect() protoreflect.Message { + mi := &file_proto_eth_v2_beacon_lightclient_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LightClientUpdateWithVersion.ProtoReflect.Descriptor instead. +func (*LightClientUpdateWithVersion) Descriptor() ([]byte, []int) { + return file_proto_eth_v2_beacon_lightclient_proto_rawDescGZIP(), []int{5} +} + +func (x *LightClientUpdateWithVersion) GetVersion() Version { + if x != nil { + return x.Version + } + return Version_PHASE0 +} + +func (x *LightClientUpdateWithVersion) GetData() *LightClientUpdate { + if x != nil { + return x.Data + } + return nil +} + +type LightClientUpdate struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + AttestedHeader *v1.BeaconBlockHeader `protobuf:"bytes,1,opt,name=attested_header,json=attestedHeader,proto3" json:"attested_header,omitempty"` + NextSyncCommittee *SyncCommittee `protobuf:"bytes,2,opt,name=next_sync_committee,json=nextSyncCommittee,proto3" json:"next_sync_committee,omitempty"` + NextSyncCommitteeBranch [][]byte `protobuf:"bytes,3,rep,name=next_sync_committee_branch,json=nextSyncCommitteeBranch,proto3" json:"next_sync_committee_branch,omitempty" ssz-size:"next_sync_committee_branch.depth,32"` + FinalizedHeader *v1.BeaconBlockHeader `protobuf:"bytes,4,opt,name=finalized_header,json=finalizedHeader,proto3" json:"finalized_header,omitempty"` + FinalityBranch [][]byte `protobuf:"bytes,5,rep,name=finality_branch,json=finalityBranch,proto3" json:"finality_branch,omitempty" ssz-size:"finality_branch.depth,32"` + SyncAggregate *v1.SyncAggregate `protobuf:"bytes,6,opt,name=sync_aggregate,json=syncAggregate,proto3" json:"sync_aggregate,omitempty"` + SignatureSlot github_com_prysmaticlabs_prysm_v4_consensus_types_primitives.Slot `protobuf:"varint,7,opt,name=signature_slot,json=signatureSlot,proto3" json:"signature_slot,omitempty" cast-type:"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives.Slot"` +} + +func (x *LightClientUpdate) Reset() { + *x = LightClientUpdate{} + if protoimpl.UnsafeEnabled { + mi := &file_proto_eth_v2_beacon_lightclient_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LightClientUpdate) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LightClientUpdate) ProtoMessage() {} + +func (x *LightClientUpdate) ProtoReflect() protoreflect.Message { + mi := &file_proto_eth_v2_beacon_lightclient_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LightClientUpdate.ProtoReflect.Descriptor instead. +func (*LightClientUpdate) Descriptor() ([]byte, []int) { + return file_proto_eth_v2_beacon_lightclient_proto_rawDescGZIP(), []int{6} +} + +func (x *LightClientUpdate) GetAttestedHeader() *v1.BeaconBlockHeader { + if x != nil { + return x.AttestedHeader + } + return nil +} + +func (x *LightClientUpdate) GetNextSyncCommittee() *SyncCommittee { + if x != nil { + return x.NextSyncCommittee + } + return nil +} + +func (x *LightClientUpdate) GetNextSyncCommitteeBranch() [][]byte { + if x != nil { + return x.NextSyncCommitteeBranch + } + return nil +} + +func (x *LightClientUpdate) GetFinalizedHeader() *v1.BeaconBlockHeader { + if x != nil { + return x.FinalizedHeader + } + return nil +} + +func (x *LightClientUpdate) GetFinalityBranch() [][]byte { + if x != nil { + return x.FinalityBranch + } + return nil +} + +func (x *LightClientUpdate) GetSyncAggregate() *v1.SyncAggregate { + if x != nil { + return x.SyncAggregate + } + return nil +} + +func (x *LightClientUpdate) GetSignatureSlot() github_com_prysmaticlabs_prysm_v4_consensus_types_primitives.Slot { + if x != nil { + return x.SignatureSlot + } + return github_com_prysmaticlabs_prysm_v4_consensus_types_primitives.Slot(0) +} + +type LightClientFinalityUpdateResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Version Version `protobuf:"varint,1,opt,name=version,proto3,enum=ethereum.eth.v2.Version" json:"version,omitempty"` + Data *LightClientFinalityUpdate `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` +} + +func (x *LightClientFinalityUpdateResponse) Reset() { + *x = LightClientFinalityUpdateResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_proto_eth_v2_beacon_lightclient_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LightClientFinalityUpdateResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LightClientFinalityUpdateResponse) ProtoMessage() {} + +func (x *LightClientFinalityUpdateResponse) ProtoReflect() protoreflect.Message { + mi := &file_proto_eth_v2_beacon_lightclient_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LightClientFinalityUpdateResponse.ProtoReflect.Descriptor instead. +func (*LightClientFinalityUpdateResponse) Descriptor() ([]byte, []int) { + return file_proto_eth_v2_beacon_lightclient_proto_rawDescGZIP(), []int{7} +} + +func (x *LightClientFinalityUpdateResponse) GetVersion() Version { + if x != nil { + return x.Version + } + return Version_PHASE0 +} + +func (x *LightClientFinalityUpdateResponse) GetData() *LightClientFinalityUpdate { + if x != nil { + return x.Data + } + return nil +} + +type LightClientFinalityUpdate struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + AttestedHeader *v1.BeaconBlockHeader `protobuf:"bytes,1,opt,name=attested_header,json=attestedHeader,proto3" json:"attested_header,omitempty"` + FinalizedHeader *v1.BeaconBlockHeader `protobuf:"bytes,2,opt,name=finalized_header,json=finalizedHeader,proto3" json:"finalized_header,omitempty"` + FinalityBranch [][]byte `protobuf:"bytes,3,rep,name=finality_branch,json=finalityBranch,proto3" json:"finality_branch,omitempty" ssz-size:"finality_branch.depth,32"` + SyncAggregate *v1.SyncAggregate `protobuf:"bytes,4,opt,name=sync_aggregate,json=syncAggregate,proto3" json:"sync_aggregate,omitempty"` + SignatureSlot github_com_prysmaticlabs_prysm_v4_consensus_types_primitives.Slot `protobuf:"varint,5,opt,name=signature_slot,json=signatureSlot,proto3" json:"signature_slot,omitempty" cast-type:"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives.Slot"` +} + +func (x *LightClientFinalityUpdate) Reset() { + *x = LightClientFinalityUpdate{} + if protoimpl.UnsafeEnabled { + mi := &file_proto_eth_v2_beacon_lightclient_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LightClientFinalityUpdate) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LightClientFinalityUpdate) ProtoMessage() {} + +func (x *LightClientFinalityUpdate) ProtoReflect() protoreflect.Message { + mi := &file_proto_eth_v2_beacon_lightclient_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LightClientFinalityUpdate.ProtoReflect.Descriptor instead. +func (*LightClientFinalityUpdate) Descriptor() ([]byte, []int) { + return file_proto_eth_v2_beacon_lightclient_proto_rawDescGZIP(), []int{8} +} + +func (x *LightClientFinalityUpdate) GetAttestedHeader() *v1.BeaconBlockHeader { + if x != nil { + return x.AttestedHeader + } + return nil +} + +func (x *LightClientFinalityUpdate) GetFinalizedHeader() *v1.BeaconBlockHeader { + if x != nil { + return x.FinalizedHeader + } + return nil +} + +func (x *LightClientFinalityUpdate) GetFinalityBranch() [][]byte { + if x != nil { + return x.FinalityBranch + } + return nil +} + +func (x *LightClientFinalityUpdate) GetSyncAggregate() *v1.SyncAggregate { + if x != nil { + return x.SyncAggregate + } + return nil +} + +func (x *LightClientFinalityUpdate) GetSignatureSlot() github_com_prysmaticlabs_prysm_v4_consensus_types_primitives.Slot { + if x != nil { + return x.SignatureSlot + } + return github_com_prysmaticlabs_prysm_v4_consensus_types_primitives.Slot(0) +} + +type LightClientOptimisticUpdateResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Version Version `protobuf:"varint,1,opt,name=version,proto3,enum=ethereum.eth.v2.Version" json:"version,omitempty"` + Data *LightClientOptimisticUpdate `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` +} + +func (x *LightClientOptimisticUpdateResponse) Reset() { + *x = LightClientOptimisticUpdateResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_proto_eth_v2_beacon_lightclient_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LightClientOptimisticUpdateResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LightClientOptimisticUpdateResponse) ProtoMessage() {} + +func (x *LightClientOptimisticUpdateResponse) ProtoReflect() protoreflect.Message { + mi := &file_proto_eth_v2_beacon_lightclient_proto_msgTypes[9] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LightClientOptimisticUpdateResponse.ProtoReflect.Descriptor instead. +func (*LightClientOptimisticUpdateResponse) Descriptor() ([]byte, []int) { + return file_proto_eth_v2_beacon_lightclient_proto_rawDescGZIP(), []int{9} +} + +func (x *LightClientOptimisticUpdateResponse) GetVersion() Version { + if x != nil { + return x.Version + } + return Version_PHASE0 +} + +func (x *LightClientOptimisticUpdateResponse) GetData() *LightClientOptimisticUpdate { + if x != nil { + return x.Data + } + return nil +} + +type LightClientOptimisticUpdate struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + AttestedHeader *v1.BeaconBlockHeader `protobuf:"bytes,1,opt,name=attested_header,json=attestedHeader,proto3" json:"attested_header,omitempty"` + SyncAggregate *v1.SyncAggregate `protobuf:"bytes,2,opt,name=sync_aggregate,json=syncAggregate,proto3" json:"sync_aggregate,omitempty"` + SignatureSlot github_com_prysmaticlabs_prysm_v4_consensus_types_primitives.Slot `protobuf:"varint,3,opt,name=signature_slot,json=signatureSlot,proto3" json:"signature_slot,omitempty" cast-type:"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives.Slot"` +} + +func (x *LightClientOptimisticUpdate) Reset() { + *x = LightClientOptimisticUpdate{} + if protoimpl.UnsafeEnabled { + mi := &file_proto_eth_v2_beacon_lightclient_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LightClientOptimisticUpdate) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LightClientOptimisticUpdate) ProtoMessage() {} + +func (x *LightClientOptimisticUpdate) ProtoReflect() protoreflect.Message { + mi := &file_proto_eth_v2_beacon_lightclient_proto_msgTypes[10] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LightClientOptimisticUpdate.ProtoReflect.Descriptor instead. +func (*LightClientOptimisticUpdate) Descriptor() ([]byte, []int) { + return file_proto_eth_v2_beacon_lightclient_proto_rawDescGZIP(), []int{10} +} + +func (x *LightClientOptimisticUpdate) GetAttestedHeader() *v1.BeaconBlockHeader { + if x != nil { + return x.AttestedHeader + } + return nil +} + +func (x *LightClientOptimisticUpdate) GetSyncAggregate() *v1.SyncAggregate { + if x != nil { + return x.SyncAggregate + } + return nil +} + +func (x *LightClientOptimisticUpdate) GetSignatureSlot() github_com_prysmaticlabs_prysm_v4_consensus_types_primitives.Slot { + if x != nil { + return x.SignatureSlot + } + return github_com_prysmaticlabs_prysm_v4_consensus_types_primitives.Slot(0) +} + +var File_proto_eth_v2_beacon_lightclient_proto protoreflect.FileDescriptor + +var file_proto_eth_v2_beacon_lightclient_proto_rawDesc = []byte{ + 0x0a, 0x25, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x32, 0x2f, 0x62, + 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x5f, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x63, 0x6c, 0x69, 0x65, 0x6e, + 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0f, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, + 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x1a, 0x1b, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, + 0x65, 0x74, 0x68, 0x2f, 0x65, 0x78, 0x74, 0x2f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x74, 0x68, + 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x74, 0x68, + 0x2f, 0x76, 0x31, 0x2f, 0x62, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1a, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x74, + 0x68, 0x2f, 0x76, 0x32, 0x2f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x1a, 0x21, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x32, + 0x2f, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x44, 0x0a, 0x1b, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x43, 0x6c, + 0x69, 0x65, 0x6e, 0x74, 0x42, 0x6f, 0x6f, 0x74, 0x73, 0x74, 0x72, 0x61, 0x70, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x25, 0x0a, 0x0a, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x72, 0x6f, + 0x6f, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x06, 0x8a, 0xb5, 0x18, 0x02, 0x33, 0x32, + 0x52, 0x09, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x8d, 0x01, 0x0a, 0x1c, + 0x4c, 0x69, 0x67, 0x68, 0x74, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x42, 0x6f, 0x6f, 0x74, 0x73, + 0x74, 0x72, 0x61, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x32, 0x0a, 0x07, + 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x18, 0x2e, + 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, + 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x12, 0x39, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, + 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, + 0x2e, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x42, 0x6f, 0x6f, 0x74, + 0x73, 0x74, 0x72, 0x61, 0x70, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x22, 0x97, 0x02, 0x0a, 0x14, + 0x4c, 0x69, 0x67, 0x68, 0x74, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x42, 0x6f, 0x6f, 0x74, 0x73, + 0x74, 0x72, 0x61, 0x70, 0x12, 0x3a, 0x0a, 0x06, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, + 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x42, 0x6c, 0x6f, + 0x63, 0x6b, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x06, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, + 0x12, 0x54, 0x0a, 0x16, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x79, 0x6e, 0x63, + 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1e, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, + 0x76, 0x32, 0x2e, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, + 0x52, 0x14, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6d, + 0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, 0x12, 0x6d, 0x0a, 0x1d, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, + 0x74, 0x5f, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, + 0x5f, 0x62, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0c, 0x42, 0x2a, 0x8a, + 0xb5, 0x18, 0x26, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x79, 0x6e, 0x63, 0x5f, + 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, 0x5f, 0x62, 0x72, 0x61, 0x6e, 0x63, 0x68, + 0x2e, 0x64, 0x65, 0x70, 0x74, 0x68, 0x2c, 0x33, 0x32, 0x52, 0x1a, 0x63, 0x75, 0x72, 0x72, 0x65, + 0x6e, 0x74, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, 0x42, + 0x72, 0x61, 0x6e, 0x63, 0x68, 0x22, 0x5b, 0x0a, 0x20, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x43, 0x6c, + 0x69, 0x65, 0x6e, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, 0x42, 0x79, 0x52, 0x61, 0x6e, + 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x5f, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, + 0x0b, 0x73, 0x74, 0x61, 0x72, 0x74, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x12, 0x14, 0x0a, 0x05, + 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x63, 0x6f, 0x75, + 0x6e, 0x74, 0x22, 0x6c, 0x0a, 0x21, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x43, 0x6c, 0x69, 0x65, 0x6e, + 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, 0x42, 0x79, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x47, 0x0a, 0x07, 0x75, 0x70, 0x64, 0x61, 0x74, + 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, + 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, 0x4c, 0x69, 0x67, 0x68, 0x74, + 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x57, 0x69, 0x74, 0x68, + 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x07, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, + 0x22, 0x8a, 0x01, 0x0a, 0x1c, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, + 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x57, 0x69, 0x74, 0x68, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, + 0x6e, 0x12, 0x32, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0e, 0x32, 0x18, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, + 0x68, 0x2e, 0x76, 0x32, 0x2e, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x07, 0x76, 0x65, + 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x36, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, + 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x43, 0x6c, 0x69, 0x65, 0x6e, + 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x22, 0xe1, 0x04, + 0x0a, 0x11, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x55, 0x70, 0x64, + 0x61, 0x74, 0x65, 0x12, 0x4b, 0x0a, 0x0f, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, + 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x65, + 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x42, + 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, + 0x52, 0x0e, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x65, 0x64, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, + 0x12, 0x4e, 0x0a, 0x13, 0x6e, 0x65, 0x78, 0x74, 0x5f, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x63, 0x6f, + 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, + 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, + 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, 0x52, 0x11, 0x6e, + 0x65, 0x78, 0x74, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, + 0x12, 0x64, 0x0a, 0x1a, 0x6e, 0x65, 0x78, 0x74, 0x5f, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x63, 0x6f, + 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, 0x5f, 0x62, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x18, 0x03, + 0x20, 0x03, 0x28, 0x0c, 0x42, 0x27, 0x8a, 0xb5, 0x18, 0x23, 0x6e, 0x65, 0x78, 0x74, 0x5f, 0x73, + 0x79, 0x6e, 0x63, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, 0x5f, 0x62, 0x72, + 0x61, 0x6e, 0x63, 0x68, 0x2e, 0x64, 0x65, 0x70, 0x74, 0x68, 0x2c, 0x33, 0x32, 0x52, 0x17, 0x6e, + 0x65, 0x78, 0x74, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, + 0x42, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x12, 0x4d, 0x0a, 0x10, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, + 0x7a, 0x65, 0x64, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x22, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, + 0x76, 0x31, 0x2e, 0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, + 0x61, 0x64, 0x65, 0x72, 0x52, 0x0f, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x48, + 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x45, 0x0a, 0x0f, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x74, + 0x79, 0x5f, 0x62, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0c, 0x42, 0x1c, + 0x8a, 0xb5, 0x18, 0x18, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x5f, 0x62, 0x72, 0x61, + 0x6e, 0x63, 0x68, 0x2e, 0x64, 0x65, 0x70, 0x74, 0x68, 0x2c, 0x33, 0x32, 0x52, 0x0e, 0x66, 0x69, + 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x42, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x12, 0x45, 0x0a, 0x0e, + 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x65, 0x18, 0x06, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, + 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x79, 0x6e, 0x63, 0x41, 0x67, 0x67, 0x72, 0x65, + 0x67, 0x61, 0x74, 0x65, 0x52, 0x0d, 0x73, 0x79, 0x6e, 0x63, 0x41, 0x67, 0x67, 0x72, 0x65, 0x67, + 0x61, 0x74, 0x65, 0x12, 0x6c, 0x0a, 0x0e, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, + 0x5f, 0x73, 0x6c, 0x6f, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x04, 0x42, 0x45, 0x82, 0xb5, 0x18, + 0x41, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x72, 0x79, 0x73, + 0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, + 0x76, 0x34, 0x2f, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x2d, 0x74, 0x79, 0x70, + 0x65, 0x73, 0x2f, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x73, 0x2e, 0x53, 0x6c, + 0x6f, 0x74, 0x52, 0x0d, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x53, 0x6c, 0x6f, + 0x74, 0x22, 0x97, 0x01, 0x0a, 0x21, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x43, 0x6c, 0x69, 0x65, 0x6e, + 0x74, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x32, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, + 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x18, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, + 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, 0x56, 0x65, 0x72, 0x73, 0x69, + 0x6f, 0x6e, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x3e, 0x0a, 0x04, 0x64, + 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x65, 0x74, 0x68, 0x65, + 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, 0x4c, 0x69, 0x67, 0x68, + 0x74, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x55, + 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x22, 0xb3, 0x03, 0x0a, 0x19, + 0x4c, 0x69, 0x67, 0x68, 0x74, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x46, 0x69, 0x6e, 0x61, 0x6c, + 0x69, 0x74, 0x79, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x4b, 0x0a, 0x0f, 0x61, 0x74, 0x74, + 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, + 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, + 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x0e, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x65, 0x64, + 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x4d, 0x0a, 0x10, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, + 0x7a, 0x65, 0x64, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x22, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, + 0x76, 0x31, 0x2e, 0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, + 0x61, 0x64, 0x65, 0x72, 0x52, 0x0f, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x48, + 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x45, 0x0a, 0x0f, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x74, + 0x79, 0x5f, 0x62, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0c, 0x42, 0x1c, + 0x8a, 0xb5, 0x18, 0x18, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x5f, 0x62, 0x72, 0x61, + 0x6e, 0x63, 0x68, 0x2e, 0x64, 0x65, 0x70, 0x74, 0x68, 0x2c, 0x33, 0x32, 0x52, 0x0e, 0x66, 0x69, + 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x42, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x12, 0x45, 0x0a, 0x0e, + 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x65, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, + 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x79, 0x6e, 0x63, 0x41, 0x67, 0x67, 0x72, 0x65, + 0x67, 0x61, 0x74, 0x65, 0x52, 0x0d, 0x73, 0x79, 0x6e, 0x63, 0x41, 0x67, 0x67, 0x72, 0x65, 0x67, + 0x61, 0x74, 0x65, 0x12, 0x6c, 0x0a, 0x0e, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, + 0x5f, 0x73, 0x6c, 0x6f, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x42, 0x45, 0x82, 0xb5, 0x18, + 0x41, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x72, 0x79, 0x73, + 0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, + 0x76, 0x34, 0x2f, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x2d, 0x74, 0x79, 0x70, + 0x65, 0x73, 0x2f, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x73, 0x2e, 0x53, 0x6c, + 0x6f, 0x74, 0x52, 0x0d, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x53, 0x6c, 0x6f, + 0x74, 0x22, 0x9b, 0x01, 0x0a, 0x23, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x43, 0x6c, 0x69, 0x65, 0x6e, + 0x74, 0x4f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x73, 0x74, 0x69, 0x63, 0x55, 0x70, 0x64, 0x61, 0x74, + 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x32, 0x0a, 0x07, 0x76, 0x65, 0x72, + 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x18, 0x2e, 0x65, 0x74, 0x68, + 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, 0x56, 0x65, 0x72, + 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x40, 0x0a, + 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x65, 0x74, + 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, 0x4c, 0x69, + 0x67, 0x68, 0x74, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x4f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x73, + 0x74, 0x69, 0x63, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x22, + 0x9f, 0x02, 0x0a, 0x1b, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x4f, + 0x70, 0x74, 0x69, 0x6d, 0x69, 0x73, 0x74, 0x69, 0x63, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, + 0x4b, 0x0a, 0x0f, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x68, 0x65, 0x61, 0x64, + 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, + 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x65, 0x61, 0x63, 0x6f, + 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x0e, 0x61, 0x74, + 0x74, 0x65, 0x73, 0x74, 0x65, 0x64, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x45, 0x0a, 0x0e, + 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, + 0x65, 0x74, 0x68, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x79, 0x6e, 0x63, 0x41, 0x67, 0x67, 0x72, 0x65, + 0x67, 0x61, 0x74, 0x65, 0x52, 0x0d, 0x73, 0x79, 0x6e, 0x63, 0x41, 0x67, 0x67, 0x72, 0x65, 0x67, + 0x61, 0x74, 0x65, 0x12, 0x6c, 0x0a, 0x0e, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, + 0x5f, 0x73, 0x6c, 0x6f, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x42, 0x45, 0x82, 0xb5, 0x18, + 0x41, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x72, 0x79, 0x73, + 0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, + 0x76, 0x34, 0x2f, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e, 0x73, 0x75, 0x73, 0x2d, 0x74, 0x79, 0x70, + 0x65, 0x73, 0x2f, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74, 0x69, 0x76, 0x65, 0x73, 0x2e, 0x53, 0x6c, + 0x6f, 0x74, 0x52, 0x0d, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x53, 0x6c, 0x6f, + 0x74, 0x42, 0x83, 0x01, 0x0a, 0x13, 0x6f, 0x72, 0x67, 0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, + 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x42, 0x12, 0x53, 0x79, 0x6e, 0x63, 0x43, + 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, + 0x32, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x72, 0x79, 0x73, + 0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, + 0x76, 0x34, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x74, 0x68, 0x2f, 0x76, 0x32, 0x3b, + 0x65, 0x74, 0x68, 0xaa, 0x02, 0x0f, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x45, + 0x74, 0x68, 0x2e, 0x56, 0x32, 0xca, 0x02, 0x0f, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, + 0x5c, 0x45, 0x74, 0x68, 0x5c, 0x76, 0x32, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_proto_eth_v2_beacon_lightclient_proto_rawDescOnce sync.Once + file_proto_eth_v2_beacon_lightclient_proto_rawDescData = file_proto_eth_v2_beacon_lightclient_proto_rawDesc +) + +func file_proto_eth_v2_beacon_lightclient_proto_rawDescGZIP() []byte { + file_proto_eth_v2_beacon_lightclient_proto_rawDescOnce.Do(func() { + file_proto_eth_v2_beacon_lightclient_proto_rawDescData = protoimpl.X.CompressGZIP(file_proto_eth_v2_beacon_lightclient_proto_rawDescData) + }) + return file_proto_eth_v2_beacon_lightclient_proto_rawDescData +} + +var file_proto_eth_v2_beacon_lightclient_proto_msgTypes = make([]protoimpl.MessageInfo, 11) +var file_proto_eth_v2_beacon_lightclient_proto_goTypes = []interface{}{ + (*LightClientBootstrapRequest)(nil), // 0: ethereum.eth.v2.LightClientBootstrapRequest + (*LightClientBootstrapResponse)(nil), // 1: ethereum.eth.v2.LightClientBootstrapResponse + (*LightClientBootstrap)(nil), // 2: ethereum.eth.v2.LightClientBootstrap + (*LightClientUpdatesByRangeRequest)(nil), // 3: ethereum.eth.v2.LightClientUpdatesByRangeRequest + (*LightClientUpdatesByRangeResponse)(nil), // 4: ethereum.eth.v2.LightClientUpdatesByRangeResponse + (*LightClientUpdateWithVersion)(nil), // 5: ethereum.eth.v2.LightClientUpdateWithVersion + (*LightClientUpdate)(nil), // 6: ethereum.eth.v2.LightClientUpdate + (*LightClientFinalityUpdateResponse)(nil), // 7: ethereum.eth.v2.LightClientFinalityUpdateResponse + (*LightClientFinalityUpdate)(nil), // 8: ethereum.eth.v2.LightClientFinalityUpdate + (*LightClientOptimisticUpdateResponse)(nil), // 9: ethereum.eth.v2.LightClientOptimisticUpdateResponse + (*LightClientOptimisticUpdate)(nil), // 10: ethereum.eth.v2.LightClientOptimisticUpdate + (Version)(0), // 11: ethereum.eth.v2.Version + (*v1.BeaconBlockHeader)(nil), // 12: ethereum.eth.v1.BeaconBlockHeader + (*SyncCommittee)(nil), // 13: ethereum.eth.v2.SyncCommittee + (*v1.SyncAggregate)(nil), // 14: ethereum.eth.v1.SyncAggregate +} +var file_proto_eth_v2_beacon_lightclient_proto_depIdxs = []int32{ + 11, // 0: ethereum.eth.v2.LightClientBootstrapResponse.version:type_name -> ethereum.eth.v2.Version + 2, // 1: ethereum.eth.v2.LightClientBootstrapResponse.data:type_name -> ethereum.eth.v2.LightClientBootstrap + 12, // 2: ethereum.eth.v2.LightClientBootstrap.header:type_name -> ethereum.eth.v1.BeaconBlockHeader + 13, // 3: ethereum.eth.v2.LightClientBootstrap.current_sync_committee:type_name -> ethereum.eth.v2.SyncCommittee + 5, // 4: ethereum.eth.v2.LightClientUpdatesByRangeResponse.updates:type_name -> ethereum.eth.v2.LightClientUpdateWithVersion + 11, // 5: ethereum.eth.v2.LightClientUpdateWithVersion.version:type_name -> ethereum.eth.v2.Version + 6, // 6: ethereum.eth.v2.LightClientUpdateWithVersion.data:type_name -> ethereum.eth.v2.LightClientUpdate + 12, // 7: ethereum.eth.v2.LightClientUpdate.attested_header:type_name -> ethereum.eth.v1.BeaconBlockHeader + 13, // 8: ethereum.eth.v2.LightClientUpdate.next_sync_committee:type_name -> ethereum.eth.v2.SyncCommittee + 12, // 9: ethereum.eth.v2.LightClientUpdate.finalized_header:type_name -> ethereum.eth.v1.BeaconBlockHeader + 14, // 10: ethereum.eth.v2.LightClientUpdate.sync_aggregate:type_name -> ethereum.eth.v1.SyncAggregate + 11, // 11: ethereum.eth.v2.LightClientFinalityUpdateResponse.version:type_name -> ethereum.eth.v2.Version + 8, // 12: ethereum.eth.v2.LightClientFinalityUpdateResponse.data:type_name -> ethereum.eth.v2.LightClientFinalityUpdate + 12, // 13: ethereum.eth.v2.LightClientFinalityUpdate.attested_header:type_name -> ethereum.eth.v1.BeaconBlockHeader + 12, // 14: ethereum.eth.v2.LightClientFinalityUpdate.finalized_header:type_name -> ethereum.eth.v1.BeaconBlockHeader + 14, // 15: ethereum.eth.v2.LightClientFinalityUpdate.sync_aggregate:type_name -> ethereum.eth.v1.SyncAggregate + 11, // 16: ethereum.eth.v2.LightClientOptimisticUpdateResponse.version:type_name -> ethereum.eth.v2.Version + 10, // 17: ethereum.eth.v2.LightClientOptimisticUpdateResponse.data:type_name -> ethereum.eth.v2.LightClientOptimisticUpdate + 12, // 18: ethereum.eth.v2.LightClientOptimisticUpdate.attested_header:type_name -> ethereum.eth.v1.BeaconBlockHeader + 14, // 19: ethereum.eth.v2.LightClientOptimisticUpdate.sync_aggregate:type_name -> ethereum.eth.v1.SyncAggregate + 20, // [20:20] is the sub-list for method output_type + 20, // [20:20] is the sub-list for method input_type + 20, // [20:20] is the sub-list for extension type_name + 20, // [20:20] is the sub-list for extension extendee + 0, // [0:20] is the sub-list for field type_name +} + +func init() { file_proto_eth_v2_beacon_lightclient_proto_init() } +func file_proto_eth_v2_beacon_lightclient_proto_init() { + if File_proto_eth_v2_beacon_lightclient_proto != nil { + return + } + file_proto_eth_v2_version_proto_init() + file_proto_eth_v2_sync_committee_proto_init() + if !protoimpl.UnsafeEnabled { + file_proto_eth_v2_beacon_lightclient_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LightClientBootstrapRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_proto_eth_v2_beacon_lightclient_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LightClientBootstrapResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_proto_eth_v2_beacon_lightclient_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LightClientBootstrap); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_proto_eth_v2_beacon_lightclient_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LightClientUpdatesByRangeRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_proto_eth_v2_beacon_lightclient_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LightClientUpdatesByRangeResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_proto_eth_v2_beacon_lightclient_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LightClientUpdateWithVersion); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_proto_eth_v2_beacon_lightclient_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LightClientUpdate); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_proto_eth_v2_beacon_lightclient_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LightClientFinalityUpdateResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_proto_eth_v2_beacon_lightclient_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LightClientFinalityUpdate); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_proto_eth_v2_beacon_lightclient_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LightClientOptimisticUpdateResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_proto_eth_v2_beacon_lightclient_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LightClientOptimisticUpdate); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_proto_eth_v2_beacon_lightclient_proto_rawDesc, + NumEnums: 0, + NumMessages: 11, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_proto_eth_v2_beacon_lightclient_proto_goTypes, + DependencyIndexes: file_proto_eth_v2_beacon_lightclient_proto_depIdxs, + MessageInfos: file_proto_eth_v2_beacon_lightclient_proto_msgTypes, + }.Build() + File_proto_eth_v2_beacon_lightclient_proto = out.File + file_proto_eth_v2_beacon_lightclient_proto_rawDesc = nil + file_proto_eth_v2_beacon_lightclient_proto_goTypes = nil + file_proto_eth_v2_beacon_lightclient_proto_depIdxs = nil +} diff --git a/proto/eth/v2/beacon_lightclient.pb.gw.go b/proto/eth/v2/beacon_lightclient.pb.gw.go new file mode 100755 index 000000000000..b76fb6098a37 --- /dev/null +++ b/proto/eth/v2/beacon_lightclient.pb.gw.go @@ -0,0 +1,3 @@ +// +build ignore + +package ignore \ No newline at end of file diff --git a/proto/eth/v2/beacon_lightclient.proto b/proto/eth/v2/beacon_lightclient.proto new file mode 100644 index 000000000000..cc271fb23c1e --- /dev/null +++ b/proto/eth/v2/beacon_lightclient.proto @@ -0,0 +1,96 @@ +// Copyright 2021 Prysmatic Labs. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +syntax = "proto3"; + +package ethereum.eth.v2; + +import "proto/eth/ext/options.proto"; +import "proto/eth/v1/attestation.proto"; +import "proto/eth/v1/beacon_block.proto"; +import "proto/eth/v2/version.proto"; +import "proto/eth/v2/sync_committee.proto"; +//import "proto/engine/v1/execution_engine.proto"; + +option csharp_namespace = "Ethereum.Eth.V2"; +option go_package = "github.com/prysmaticlabs/prysm/v4/proto/eth/v2;eth"; +option java_multiple_files = true; +option java_outer_classname = "SyncCommitteeProto"; +option java_package = "org.ethereum.eth.v2"; +option php_namespace = "Ethereum\\Eth\\v2"; + +// Beacon LightClient API related messages. + +message LightClientBootstrapRequest { + // 32 byte merkle tree root of the ssz encoded block. + bytes block_root = 1 [(ethereum.eth.ext.ssz_size) = "32"]; +} + +message LightClientBootstrapResponse { + v2.Version version = 1; + LightClientBootstrap data = 2; +} + +message LightClientBootstrap { + v1.BeaconBlockHeader header = 1; + SyncCommittee current_sync_committee = 2; + repeated bytes current_sync_committee_branch = 3 [(ethereum.eth.ext.ssz_size) = "current_sync_committee_branch.depth,32"]; +} + +message LightClientUpdatesByRangeRequest { + uint64 start_period = 1; + uint32 count = 2; +} + +message LightClientUpdatesByRangeResponse { + repeated LightClientUpdateWithVersion updates = 1; +} + +message LightClientUpdateWithVersion { + v2.Version version = 1; + LightClientUpdate data = 2; +} + +message LightClientUpdate { + v1.BeaconBlockHeader attested_header = 1; + SyncCommittee next_sync_committee = 2; + repeated bytes next_sync_committee_branch = 3 [(ethereum.eth.ext.ssz_size) = "next_sync_committee_branch.depth,32"]; + v1.BeaconBlockHeader finalized_header = 4; + repeated bytes finality_branch = 5 [(ethereum.eth.ext.ssz_size) = "finality_branch.depth,32"]; + v1.SyncAggregate sync_aggregate = 6; + uint64 signature_slot = 7 [(ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives.Slot"]; +} + +message LightClientFinalityUpdateResponse { + v2.Version version = 1; + LightClientFinalityUpdate data = 2; +} + +message LightClientFinalityUpdate { + v1.BeaconBlockHeader attested_header = 1; + v1.BeaconBlockHeader finalized_header = 2; + repeated bytes finality_branch = 3 [(ethereum.eth.ext.ssz_size) = "finality_branch.depth,32"]; + v1.SyncAggregate sync_aggregate = 4; + uint64 signature_slot = 5 [(ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives.Slot"]; +} + +message LightClientOptimisticUpdateResponse { + v2.Version version = 1; + LightClientOptimisticUpdate data = 2; +} + +message LightClientOptimisticUpdate { + v1.BeaconBlockHeader attested_header = 1; + v1.SyncAggregate sync_aggregate = 2; + uint64 signature_slot = 3 [(ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives.Slot"]; +} diff --git a/proto/eth/v2/beacon_state.pb.go b/proto/eth/v2/beacon_state.pb.go index 25474da85928..eee9bfbcb56c 100755 --- a/proto/eth/v2/beacon_state.pb.go +++ b/proto/eth/v2/beacon_state.pb.go @@ -1,22 +1,21 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.30.0 -// protoc v3.15.8 +// protoc v4.23.3 // source: proto/eth/v2/beacon_state.proto package eth import ( - reflect "reflect" - sync "sync" - + v11 "github.com/prysmaticlabs/prysm/v4/proto/engine/v1" github_com_prysmaticlabs_go_bitfield "github.com/prysmaticlabs/go-bitfield" github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" - v11 "github.com/prysmaticlabs/prysm/v4/proto/engine/v1" _ "github.com/prysmaticlabs/prysm/v4/proto/eth/ext" v1 "github.com/prysmaticlabs/prysm/v4/proto/eth/v1" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" ) const ( diff --git a/proto/eth/v2/beacon_state.pb.gw.go b/proto/eth/v2/beacon_state.pb.gw.go index cdd03643f0c7..b76fb6098a37 100755 --- a/proto/eth/v2/beacon_state.pb.gw.go +++ b/proto/eth/v2/beacon_state.pb.gw.go @@ -1,4 +1,3 @@ -//go:build ignore // +build ignore -package ignore +package ignore \ No newline at end of file diff --git a/proto/eth/v2/custom.go b/proto/eth/v2/custom.go new file mode 100644 index 000000000000..86132bd84e2b --- /dev/null +++ b/proto/eth/v2/custom.go @@ -0,0 +1,51 @@ +package eth + +import ( + "bytes" + "math/bits" +) + +const ( + NextSyncCommitteeIndex = uint64(55) + FinalizedRootIndex = uint64(105) +) + +func (x *SyncCommittee) Equals(other *SyncCommittee) bool { + if len(x.Pubkeys) != len(other.Pubkeys) { + return false + } + for i := range x.Pubkeys { + if !bytes.Equal(x.Pubkeys[i], other.Pubkeys[i]) { + return false + } + } + return bytes.Equal(x.AggregatePubkey, other.AggregatePubkey) +} + +func FloorLog2(x uint64) int { + return bits.Len64(uint64(x - 1)) +} + +func isEmptyWithLength(bb [][]byte, length uint64) bool { + if len(bb) == 0 { + return true + } + l := FloorLog2(length) + if len(bb) != l { + return false + } + for _, b := range bb { + if !bytes.Equal(b, []byte{}) { + return false + } + } + return true +} + +func (x *LightClientUpdate) IsSyncCommiteeUpdate() bool { + return !isEmptyWithLength(x.GetNextSyncCommitteeBranch(), NextSyncCommitteeIndex) +} + +func (x *LightClientUpdate) IsFinalityUpdate() bool { + return !isEmptyWithLength(x.GetFinalityBranch(), FinalizedRootIndex) +} diff --git a/proto/eth/v2/generated.ssz.go b/proto/eth/v2/generated.ssz.go index 6dfb0d930fe8..134a88d7d3d5 100644 --- a/proto/eth/v2/generated.ssz.go +++ b/proto/eth/v2/generated.ssz.go @@ -3982,6 +3982,116 @@ func (b *BeaconBlockBodyAltair) HashTreeRootWith(hh *ssz.Hasher) (err error) { return } +// MarshalSSZ ssz marshals the SyncCommittee object +func (s *SyncCommittee) MarshalSSZ() ([]byte, error) { + return ssz.MarshalSSZ(s) +} + +// MarshalSSZTo ssz marshals the SyncCommittee object to a target array +func (s *SyncCommittee) MarshalSSZTo(buf []byte) (dst []byte, err error) { + dst = buf + + // Field (0) 'Pubkeys' + if size := len(s.Pubkeys); size != 512 { + err = ssz.ErrVectorLengthFn("--.Pubkeys", size, 512) + return + } + for ii := 0; ii < 512; ii++ { + if size := len(s.Pubkeys[ii]); size != 48 { + err = ssz.ErrBytesLengthFn("--.Pubkeys[ii]", size, 48) + return + } + dst = append(dst, s.Pubkeys[ii]...) + } + + // Field (1) 'AggregatePubkey' + if size := len(s.AggregatePubkey); size != 48 { + err = ssz.ErrBytesLengthFn("--.AggregatePubkey", size, 48) + return + } + dst = append(dst, s.AggregatePubkey...) + + return +} + +// UnmarshalSSZ ssz unmarshals the SyncCommittee object +func (s *SyncCommittee) UnmarshalSSZ(buf []byte) error { + var err error + size := uint64(len(buf)) + if size != 24624 { + return ssz.ErrSize + } + + // Field (0) 'Pubkeys' + s.Pubkeys = make([][]byte, 512) + for ii := 0; ii < 512; ii++ { + if cap(s.Pubkeys[ii]) == 0 { + s.Pubkeys[ii] = make([]byte, 0, len(buf[0:24576][ii*48:(ii+1)*48])) + } + s.Pubkeys[ii] = append(s.Pubkeys[ii], buf[0:24576][ii*48:(ii+1)*48]...) + } + + // Field (1) 'AggregatePubkey' + if cap(s.AggregatePubkey) == 0 { + s.AggregatePubkey = make([]byte, 0, len(buf[24576:24624])) + } + s.AggregatePubkey = append(s.AggregatePubkey, buf[24576:24624]...) + + return err +} + +// SizeSSZ returns the ssz encoded size in bytes for the SyncCommittee object +func (s *SyncCommittee) SizeSSZ() (size int) { + size = 24624 + return +} + +// HashTreeRoot ssz hashes the SyncCommittee object +func (s *SyncCommittee) HashTreeRoot() ([32]byte, error) { + return ssz.HashWithDefaultHasher(s) +} + +// HashTreeRootWith ssz hashes the SyncCommittee object with a hasher +func (s *SyncCommittee) HashTreeRootWith(hh *ssz.Hasher) (err error) { + indx := hh.Index() + + // Field (0) 'Pubkeys' + { + if size := len(s.Pubkeys); size != 512 { + err = ssz.ErrVectorLengthFn("--.Pubkeys", size, 512) + return + } + subIndx := hh.Index() + for _, i := range s.Pubkeys { + if len(i) != 48 { + err = ssz.ErrBytesLength + return + } + hh.PutBytes(i) + } + + if ssz.EnableVectorizedHTR { + hh.MerkleizeVectorizedHTR(subIndx) + } else { + hh.Merkleize(subIndx) + } + } + + // Field (1) 'AggregatePubkey' + if size := len(s.AggregatePubkey); size != 48 { + err = ssz.ErrBytesLengthFn("--.AggregatePubkey", size, 48) + return + } + hh.PutBytes(s.AggregatePubkey) + + if ssz.EnableVectorizedHTR { + hh.MerkleizeVectorizedHTR(indx) + } else { + hh.Merkleize(indx) + } + return +} + // MarshalSSZ ssz marshals the BLSToExecutionChange object func (b *BLSToExecutionChange) MarshalSSZ() ([]byte, error) { return ssz.MarshalSSZ(b) diff --git a/proto/eth/v2/ssz.pb.go b/proto/eth/v2/ssz.pb.go index 16a5c391dc22..bc7464ee83d7 100755 --- a/proto/eth/v2/ssz.pb.go +++ b/proto/eth/v2/ssz.pb.go @@ -1,17 +1,16 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.30.0 -// protoc v3.15.8 +// protoc v4.23.3 // source: proto/eth/v2/ssz.proto package eth import ( - reflect "reflect" - sync "sync" - protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" ) const ( diff --git a/proto/eth/v2/ssz.pb.gw.go b/proto/eth/v2/ssz.pb.gw.go index cdd03643f0c7..b76fb6098a37 100755 --- a/proto/eth/v2/ssz.pb.gw.go +++ b/proto/eth/v2/ssz.pb.gw.go @@ -1,4 +1,3 @@ -//go:build ignore // +build ignore -package ignore +package ignore \ No newline at end of file diff --git a/proto/eth/v2/sync_committee.pb.go b/proto/eth/v2/sync_committee.pb.go index df50925fc762..a06c3fa06520 100755 --- a/proto/eth/v2/sync_committee.pb.go +++ b/proto/eth/v2/sync_committee.pb.go @@ -1,19 +1,18 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.30.0 -// protoc v3.15.8 +// protoc v4.23.3 // source: proto/eth/v2/sync_committee.proto package eth import ( - reflect "reflect" - sync "sync" - - github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" _ "github.com/prysmaticlabs/prysm/v4/proto/eth/ext" + github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" ) const ( diff --git a/proto/eth/v2/sync_committee.pb.gw.go b/proto/eth/v2/sync_committee.pb.gw.go index cdd03643f0c7..b76fb6098a37 100755 --- a/proto/eth/v2/sync_committee.pb.gw.go +++ b/proto/eth/v2/sync_committee.pb.gw.go @@ -1,4 +1,3 @@ -//go:build ignore // +build ignore -package ignore +package ignore \ No newline at end of file diff --git a/proto/eth/v2/validator.pb.go b/proto/eth/v2/validator.pb.go index d1c8570532bd..e08ffd155b90 100755 --- a/proto/eth/v2/validator.pb.go +++ b/proto/eth/v2/validator.pb.go @@ -1,20 +1,19 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.30.0 -// protoc v3.15.8 +// protoc v4.23.3 // source: proto/eth/v2/validator.proto package eth import ( - reflect "reflect" - sync "sync" - + _ "github.com/prysmaticlabs/prysm/v4/proto/eth/ext" github_com_prysmaticlabs_go_bitfield "github.com/prysmaticlabs/go-bitfield" github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" - _ "github.com/prysmaticlabs/prysm/v4/proto/eth/ext" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" ) const ( diff --git a/proto/eth/v2/validator.pb.gw.go b/proto/eth/v2/validator.pb.gw.go index cdd03643f0c7..b76fb6098a37 100755 --- a/proto/eth/v2/validator.pb.gw.go +++ b/proto/eth/v2/validator.pb.gw.go @@ -1,4 +1,3 @@ -//go:build ignore // +build ignore -package ignore +package ignore \ No newline at end of file diff --git a/proto/eth/v2/version.pb.go b/proto/eth/v2/version.pb.go index f23f15cdace2..3f8547d841c2 100755 --- a/proto/eth/v2/version.pb.go +++ b/proto/eth/v2/version.pb.go @@ -1,17 +1,16 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.30.0 -// protoc v3.15.8 +// protoc v4.23.3 // source: proto/eth/v2/version.proto package eth import ( - reflect "reflect" - sync "sync" - protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" ) const ( diff --git a/proto/eth/v2/version.pb.gw.go b/proto/eth/v2/version.pb.gw.go index cdd03643f0c7..b76fb6098a37 100755 --- a/proto/eth/v2/version.pb.gw.go +++ b/proto/eth/v2/version.pb.gw.go @@ -1,4 +1,3 @@ -//go:build ignore // +build ignore -package ignore +package ignore \ No newline at end of file diff --git a/proto/eth/v2/withdrawals.pb.go b/proto/eth/v2/withdrawals.pb.go index 8e5362705d7c..01b43cd4d92e 100755 --- a/proto/eth/v2/withdrawals.pb.go +++ b/proto/eth/v2/withdrawals.pb.go @@ -1,19 +1,18 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.30.0 -// protoc v3.15.8 +// protoc v4.23.3 // source: proto/eth/v2/withdrawals.proto package eth import ( - reflect "reflect" - sync "sync" - - github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" _ "github.com/prysmaticlabs/prysm/v4/proto/eth/ext" + github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" ) const ( diff --git a/proto/prysm/v1alpha1/attestation.pb.go b/proto/prysm/v1alpha1/attestation.pb.go index c9bfde880a3e..4b64f745b21a 100755 --- a/proto/prysm/v1alpha1/attestation.pb.go +++ b/proto/prysm/v1alpha1/attestation.pb.go @@ -1,20 +1,19 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.30.0 -// protoc v3.15.8 +// protoc v4.23.3 // source: proto/prysm/v1alpha1/attestation.proto package eth import ( - reflect "reflect" - sync "sync" - - github_com_prysmaticlabs_go_bitfield "github.com/prysmaticlabs/go-bitfield" - github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" _ "github.com/prysmaticlabs/prysm/v4/proto/eth/ext" + github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" + github_com_prysmaticlabs_go_bitfield "github.com/prysmaticlabs/go-bitfield" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" ) const ( diff --git a/proto/prysm/v1alpha1/beacon_block.pb.go b/proto/prysm/v1alpha1/beacon_block.pb.go index c860c08144c9..685a33a6a745 100755 --- a/proto/prysm/v1alpha1/beacon_block.pb.go +++ b/proto/prysm/v1alpha1/beacon_block.pb.go @@ -1,21 +1,20 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.30.0 -// protoc v3.15.8 +// protoc v4.23.3 // source: proto/prysm/v1alpha1/beacon_block.proto package eth import ( - reflect "reflect" - sync "sync" - + v1 "github.com/prysmaticlabs/prysm/v4/proto/engine/v1" github_com_prysmaticlabs_go_bitfield "github.com/prysmaticlabs/go-bitfield" github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" - v1 "github.com/prysmaticlabs/prysm/v4/proto/engine/v1" _ "github.com/prysmaticlabs/prysm/v4/proto/eth/ext" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" ) const ( diff --git a/proto/prysm/v1alpha1/beacon_chain.pb.go b/proto/prysm/v1alpha1/beacon_chain.pb.go index 1492cf04cef4..a276ed0c0a16 100755 --- a/proto/prysm/v1alpha1/beacon_chain.pb.go +++ b/proto/prysm/v1alpha1/beacon_chain.pb.go @@ -1,25 +1,24 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.30.0 -// protoc v3.15.8 +// protoc v4.23.3 // source: proto/prysm/v1alpha1/beacon_chain.proto package eth import ( context "context" - reflect "reflect" - sync "sync" - empty "github.com/golang/protobuf/ptypes/empty" - github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" _ "github.com/prysmaticlabs/prysm/v4/proto/eth/ext" + github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" _ "google.golang.org/genproto/googleapis/api/annotations" grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" ) const ( diff --git a/proto/prysm/v1alpha1/beacon_state.pb.go b/proto/prysm/v1alpha1/beacon_state.pb.go index 54011cfee2e3..c18eb6f849a9 100755 --- a/proto/prysm/v1alpha1/beacon_state.pb.go +++ b/proto/prysm/v1alpha1/beacon_state.pb.go @@ -1,21 +1,20 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.30.0 -// protoc v3.15.8 +// protoc v4.23.3 // source: proto/prysm/v1alpha1/beacon_state.proto package eth import ( - reflect "reflect" - sync "sync" - + v1 "github.com/prysmaticlabs/prysm/v4/proto/engine/v1" github_com_prysmaticlabs_go_bitfield "github.com/prysmaticlabs/go-bitfield" github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" - v1 "github.com/prysmaticlabs/prysm/v4/proto/engine/v1" _ "github.com/prysmaticlabs/prysm/v4/proto/eth/ext" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" ) const ( diff --git a/proto/prysm/v1alpha1/debug.pb.go b/proto/prysm/v1alpha1/debug.pb.go index 573361103fc0..8a0fdbf1beac 100755 --- a/proto/prysm/v1alpha1/debug.pb.go +++ b/proto/prysm/v1alpha1/debug.pb.go @@ -1,25 +1,24 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.30.0 -// protoc v3.15.8 +// protoc v4.23.3 // source: proto/prysm/v1alpha1/debug.proto package eth import ( context "context" - reflect "reflect" - sync "sync" - empty "github.com/golang/protobuf/ptypes/empty" - github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" _ "github.com/prysmaticlabs/prysm/v4/proto/eth/ext" + github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" _ "google.golang.org/genproto/googleapis/api/annotations" grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" ) const ( diff --git a/proto/prysm/v1alpha1/finalized_block_root_container.pb.go b/proto/prysm/v1alpha1/finalized_block_root_container.pb.go index 58ff028f9d2d..983ec6801d97 100755 --- a/proto/prysm/v1alpha1/finalized_block_root_container.pb.go +++ b/proto/prysm/v1alpha1/finalized_block_root_container.pb.go @@ -1,17 +1,16 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.30.0 -// protoc v3.15.8 +// protoc v4.23.3 // source: proto/prysm/v1alpha1/finalized_block_root_container.proto package eth import ( - reflect "reflect" - sync "sync" - protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" ) const ( diff --git a/proto/prysm/v1alpha1/health.pb.go b/proto/prysm/v1alpha1/health.pb.go index e354b5937755..2e15cb0992ca 100755 --- a/proto/prysm/v1alpha1/health.pb.go +++ b/proto/prysm/v1alpha1/health.pb.go @@ -1,16 +1,13 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.30.0 -// protoc v3.15.8 +// protoc v4.23.3 // source: proto/prysm/v1alpha1/health.proto package eth import ( context "context" - reflect "reflect" - sync "sync" - empty "github.com/golang/protobuf/ptypes/empty" _ "google.golang.org/genproto/googleapis/api/annotations" grpc "google.golang.org/grpc" @@ -18,6 +15,8 @@ import ( status "google.golang.org/grpc/status" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" ) const ( diff --git a/proto/prysm/v1alpha1/node.pb.go b/proto/prysm/v1alpha1/node.pb.go index 5609aa59c203..5233b7b3613d 100755 --- a/proto/prysm/v1alpha1/node.pb.go +++ b/proto/prysm/v1alpha1/node.pb.go @@ -1,16 +1,13 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.30.0 -// protoc v3.15.8 +// protoc v4.23.3 // source: proto/prysm/v1alpha1/node.proto package eth import ( context "context" - reflect "reflect" - sync "sync" - empty "github.com/golang/protobuf/ptypes/empty" timestamp "github.com/golang/protobuf/ptypes/timestamp" _ "github.com/prysmaticlabs/prysm/v4/proto/eth/ext" @@ -20,6 +17,8 @@ import ( status "google.golang.org/grpc/status" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" ) const ( diff --git a/proto/prysm/v1alpha1/p2p_messages.pb.go b/proto/prysm/v1alpha1/p2p_messages.pb.go index b451580b00fe..008883cc2c95 100755 --- a/proto/prysm/v1alpha1/p2p_messages.pb.go +++ b/proto/prysm/v1alpha1/p2p_messages.pb.go @@ -1,21 +1,20 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.30.0 -// protoc v3.15.8 +// protoc v4.23.3 // source: proto/prysm/v1alpha1/p2p_messages.proto package eth import ( - reflect "reflect" - sync "sync" - _ "github.com/golang/protobuf/protoc-gen-go/descriptor" + _ "github.com/prysmaticlabs/prysm/v4/proto/eth/ext" github_com_prysmaticlabs_go_bitfield "github.com/prysmaticlabs/go-bitfield" github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" - _ "github.com/prysmaticlabs/prysm/v4/proto/eth/ext" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" ) const ( diff --git a/proto/prysm/v1alpha1/powchain.pb.go b/proto/prysm/v1alpha1/powchain.pb.go index 69f50efe6d31..b0cfecf440b5 100755 --- a/proto/prysm/v1alpha1/powchain.pb.go +++ b/proto/prysm/v1alpha1/powchain.pb.go @@ -1,17 +1,16 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.30.0 -// protoc v3.15.8 +// protoc v4.23.3 // source: proto/prysm/v1alpha1/powchain.proto package eth import ( - reflect "reflect" - sync "sync" - protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" ) const ( diff --git a/proto/prysm/v1alpha1/slasher.pb.go b/proto/prysm/v1alpha1/slasher.pb.go index 0b3621d8c32c..a6dfcd299576 100755 --- a/proto/prysm/v1alpha1/slasher.pb.go +++ b/proto/prysm/v1alpha1/slasher.pb.go @@ -1,24 +1,23 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.30.0 -// protoc v3.15.8 +// protoc v4.23.3 // source: proto/prysm/v1alpha1/slasher.proto package eth import ( context "context" - reflect "reflect" - sync "sync" - - github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" _ "github.com/prysmaticlabs/prysm/v4/proto/eth/ext" + github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" _ "google.golang.org/genproto/googleapis/api/annotations" grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" ) const ( diff --git a/proto/prysm/v1alpha1/sync_committee.pb.go b/proto/prysm/v1alpha1/sync_committee.pb.go index 69a9f32b3283..3b77b230d3f0 100755 --- a/proto/prysm/v1alpha1/sync_committee.pb.go +++ b/proto/prysm/v1alpha1/sync_committee.pb.go @@ -1,20 +1,19 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.30.0 -// protoc v3.15.8 +// protoc v4.23.3 // source: proto/prysm/v1alpha1/sync_committee.proto package eth import ( - reflect "reflect" - sync "sync" - + _ "github.com/prysmaticlabs/prysm/v4/proto/eth/ext" github_com_prysmaticlabs_go_bitfield "github.com/prysmaticlabs/go-bitfield" github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" - _ "github.com/prysmaticlabs/prysm/v4/proto/eth/ext" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" ) const ( diff --git a/proto/prysm/v1alpha1/validator.pb.go b/proto/prysm/v1alpha1/validator.pb.go index 0f9084091bc8..797e9ac061a0 100755 --- a/proto/prysm/v1alpha1/validator.pb.go +++ b/proto/prysm/v1alpha1/validator.pb.go @@ -1,25 +1,24 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.30.0 -// protoc v3.15.8 +// protoc v4.23.3 // source: proto/prysm/v1alpha1/validator.proto package eth import ( context "context" - reflect "reflect" - sync "sync" - empty "github.com/golang/protobuf/ptypes/empty" - github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" _ "github.com/prysmaticlabs/prysm/v4/proto/eth/ext" + github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" _ "google.golang.org/genproto/googleapis/api/annotations" grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" ) const ( diff --git a/proto/prysm/v1alpha1/withdrawals.pb.go b/proto/prysm/v1alpha1/withdrawals.pb.go index f2033d89cd9b..72c5bffc2a52 100755 --- a/proto/prysm/v1alpha1/withdrawals.pb.go +++ b/proto/prysm/v1alpha1/withdrawals.pb.go @@ -1,19 +1,18 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.30.0 -// protoc v3.15.8 +// protoc v4.23.3 // source: proto/prysm/v1alpha1/withdrawals.proto package eth import ( - reflect "reflect" - sync "sync" - - github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" _ "github.com/prysmaticlabs/prysm/v4/proto/eth/ext" + github_com_prysmaticlabs_prysm_v4_consensus_types_primitives "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" ) const (