github/prysm
1
1
Fork 0
mirror of https://github.com/OffchainLabs/prysm.git synced 2026-01-09 15:37:56 -05:00
Code Issues Packages Projects Releases Wiki Activity

Update Configuration, Naming, and GenesisStart to Accommodate Randao (#1647)

Browse Source 
* signature on startup configuration

* remove ref to hash32s for randao

* completed changes
This commit is contained in:
Raul Jordan
2019-02-19 14:24:00 -06:00
committed by GitHub
parent ef4a7e07cc
commit 2425bef5c7
21 changed files with 445 additions and 441 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
beacon-chain/chaintest/backend/helpers.go
View File

@@ -29,10 +29,10 @@ func generateSimulatedBlock(
}
randaoReveal := [32]byte{}
block := &pb.BeaconBlock{
Slot: beaconState.Slot + 1,
RandaoRevealHash32: randaoReveal[:],
ParentRootHash32: prevBlockRoot[:],
StateRootHash32: stateRoot[:],
Slot: beaconState.Slot + 1,
RandaoReveal: randaoReveal[:],
ParentRootHash32: prevBlockRoot[:],
StateRootHash32: stateRoot[:],
Eth1Data: &pb.Eth1Data{
DepositRootHash32: []byte{1},
BlockHash32: []byte{2},

10
beacon-chain/core/blocks/block.go
View File

@@ -19,11 +19,11 @@ var clock utils.Clock = &utils.RealClock{}
// NewGenesisBlock returns the canonical, genesis block for the beacon chain protocol.
func NewGenesisBlock(stateRoot []byte) *pb.BeaconBlock {
block := &pb.BeaconBlock{
Slot: params.BeaconConfig().GenesisSlot,
ParentRootHash32: params.BeaconConfig().ZeroHash[:],
StateRootHash32: stateRoot,
RandaoRevealHash32: params.BeaconConfig().ZeroHash[:],
Signature: params.BeaconConfig().EmptySignature,
Slot: params.BeaconConfig().GenesisSlot,
ParentRootHash32: params.BeaconConfig().ZeroHash[:],
StateRootHash32: stateRoot,
RandaoReveal: params.BeaconConfig().ZeroHash[:],
Signature: params.BeaconConfig().EmptySignature[:],
Eth1Data: &pb.Eth1Data{
DepositRootHash32: params.BeaconConfig().ZeroHash[:],
BlockHash32: params.BeaconConfig().ZeroHash[:],

6
beacon-chain/core/blocks/block_operations.go
View File

@@ -84,12 +84,12 @@ func ProcessBlockRandao(beaconState *pb.BeaconState, block *pb.BeaconBlock) (*pb
// randao and update the state's corresponding latest randao mix value.
latestMixesLength := params.BeaconConfig().LatestRandaoMixesLength
currentEpoch := helpers.CurrentEpoch(beaconState)
latestMixSlice := beaconState.LatestRandaoMixesHash32S[currentEpoch%latestMixesLength]
latestMixSlice := beaconState.LatestRandaoMixes[currentEpoch%latestMixesLength]
latestMix := bytesutil.ToBytes32(latestMixSlice)
for i, x := range block.RandaoRevealHash32 {
for i, x := range block.RandaoReveal {
latestMix[i] ^= x
}
beaconState.LatestRandaoMixesHash32S[beaconState.Slot%latestMixesLength] = latestMix[:]
beaconState.LatestRandaoMixes[beaconState.Slot%latestMixesLength] = latestMix[:]
return beaconState, nil
}

10
beacon-chain/core/blocks/block_operations_test.go
View File

@@ -27,12 +27,12 @@ func TestProcessBlockRandao_CreateRandaoMixAndUpdateProposer(t *testing.T) {
randaoCommit := bytesutil.ToBytes32([]byte("randao"))
block := &pb.BeaconBlock{
RandaoRevealHash32: randaoCommit[:],
RandaoReveal: randaoCommit[:],
}
beaconState := &pb.BeaconState{
ValidatorRegistry: validators,
Slot: 1,
LatestRandaoMixesHash32S: make([][]byte, params.BeaconConfig().LatestRandaoMixesLength),
ValidatorRegistry: validators,
Slot: 1,
LatestRandaoMixes: make([][]byte, params.BeaconConfig().LatestRandaoMixesLength),
}
newState, err := ProcessBlockRandao(
@@ -43,7 +43,7 @@ func TestProcessBlockRandao_CreateRandaoMixAndUpdateProposer(t *testing.T) {
t.Fatalf("Unexpected error processing block randao: %v", err)
}
updatedLatestMix := newState.LatestRandaoMixesHash32S[newState.Slot%params.BeaconConfig().LatestRandaoMixesLength]
updatedLatestMix := newState.LatestRandaoMixes[newState.Slot%params.BeaconConfig().LatestRandaoMixesLength]
if !bytes.Equal(updatedLatestMix, randaoCommit[:]) {
t.Errorf("Expected randao mix to XOR correctly: wanted %#x, received %#x", randaoCommit[:], updatedLatestMix)
}

4
beacon-chain/core/blocks/block_test.go
View File

@@ -26,8 +26,8 @@ func TestGenesisBlock(t *testing.T) {
t.Errorf("genesis block should have 0 attestations")
}
if !bytes.Equal(b1.RandaoRevealHash32, params.BeaconConfig().ZeroHash[:]) {
t.Error("genesis block missing RandaoRevealHash32 field")
if !bytes.Equal(b1.RandaoReveal, params.BeaconConfig().ZeroHash[:]) {
t.Error("genesis block missing RandaoReveal field")
}
if !bytes.Equal(b1.StateRootHash32, stateHash) {

2
beacon-chain/core/epoch/epoch_processing.go
View File

@@ -365,6 +365,6 @@ func UpdateLatestRandaoMixes(state *pb.BeaconState) (*pb.BeaconState, error) {
return nil, fmt.Errorf("could not get randaoMix mix: %v", err)
}
state.LatestRandaoMixesHash32S[nextEpoch] = randaoMix
state.LatestRandaoMixes[nextEpoch] = randaoMix
return state, nil
}

20
beacon-chain/core/epoch/epoch_processing_test.go
View File

@@ -455,7 +455,7 @@ func TestProcessPrevSlotShardOk(t *testing.T) {
func TestProcessValidatorRegistryOk(t *testing.T) {
state := &pb.BeaconState{
Slot: params.BeaconConfig().MinSeedLookahead,
LatestRandaoMixesHash32S: [][]byte{{'A'}, {'B'}},
LatestRandaoMixes: [][]byte{{'A'}, {'B'}},
CurrentShufflingSeedHash32: []byte{'C'},
}
newState, err := ProcessValidatorRegistry(
@@ -467,17 +467,17 @@ func TestProcessValidatorRegistryOk(t *testing.T) {
t.Errorf("Incorret curr epoch calculation slot: Wanted: %d, got: %d",
newState.CurrentShufflingEpoch, state.Slot)
}
if !bytes.Equal(newState.CurrentShufflingSeedHash32, state.LatestRandaoMixesHash32S[0]) {
if !bytes.Equal(newState.CurrentShufflingSeedHash32, state.LatestRandaoMixes[0]) {
t.Errorf("Incorret current epoch seed mix hash: Wanted: %v, got: %v",
state.LatestRandaoMixesHash32S[0], newState.CurrentShufflingSeedHash32)
state.LatestRandaoMixes[0], newState.CurrentShufflingSeedHash32)
}
}
func TestProcessPartialValidatorRegistry(t *testing.T) {
state := &pb.BeaconState{
Slot: params.BeaconConfig().SlotsPerEpoch * 2,
LatestRandaoMixesHash32S: [][]byte{{'A'}, {'B'}, {'C'}},
LatestIndexRootHash32S: [][]byte{{'D'}, {'E'}, {'F'}},
Slot: params.BeaconConfig().SlotsPerEpoch * 2,
LatestRandaoMixes: [][]byte{{'A'}, {'B'}, {'C'}},
LatestIndexRootHash32S: [][]byte{{'D'}, {'E'}, {'F'}},
}
copiedState := proto.Clone(state).(*pb.BeaconState)
newState, err := ProcessPartialValidatorRegistry(copiedState)
@@ -599,17 +599,17 @@ func TestUpdateLatestRandaoMixes_Ok(t *testing.T) {
params.BeaconConfig().LatestRandaoMixesLength)
latestSlashedRandaoMixes[epoch] = tt.seed
state := &pb.BeaconState{
Slot: tt.epoch * params.BeaconConfig().SlotsPerEpoch,
LatestRandaoMixesHash32S: latestSlashedRandaoMixes}
Slot: tt.epoch * params.BeaconConfig().SlotsPerEpoch,
LatestRandaoMixes: latestSlashedRandaoMixes}
newState, err := UpdateLatestRandaoMixes(state)
if err != nil {
t.Fatalf("could not update latest randao mixes: %v", err)
}
if !bytes.Equal(newState.LatestRandaoMixesHash32S[epoch+1], tt.seed) {
if !bytes.Equal(newState.LatestRandaoMixes[epoch+1], tt.seed) {
t.Errorf(
"LatestRandaoMixes didn't update for epoch %d,"+
"wanted: %v, got: %v", epoch+1, tt.seed,
newState.LatestRandaoMixesHash32S[epoch+1],
newState.LatestRandaoMixes[epoch+1],
)
}
}

2
beacon-chain/core/helpers/randao.go
View File

@@ -79,5 +79,5 @@ func RandaoMix(state *pb.BeaconState, wantedEpoch uint64) ([]byte, error) {
return nil, fmt.Errorf("input randaoMix epoch %d out of bounds: %d <= epoch < %d",
wantedEpoch, earliestEpoch, currentEpoch)
}
return state.LatestRandaoMixesHash32S[wantedEpoch%params.BeaconConfig().LatestRandaoMixesLength], nil
return state.LatestRandaoMixes[wantedEpoch%params.BeaconConfig().LatestRandaoMixesLength], nil
}

8
beacon-chain/core/helpers/randao_test.go
View File

@@ -18,7 +18,7 @@ func TestRandaoMix_Ok(t *testing.T) {
binary.LittleEndian.PutUint64(intInBytes, uint64(i))
randaoMixes[i] = intInBytes
}
state := &pb.BeaconState{LatestRandaoMixesHash32S: randaoMixes}
state := &pb.BeaconState{LatestRandaoMixes: randaoMixes}
tests := []struct {
epoch uint64
randaoMix []byte
@@ -132,9 +132,9 @@ func TestGenerateSeed_Ok(t *testing.T) {
}
slot := 10 * params.BeaconConfig().MinSeedLookahead * params.BeaconConfig().SlotsPerEpoch
state := &pb.BeaconState{
LatestIndexRootHash32S: activeIndexRoots,
LatestRandaoMixesHash32S: randaoMixes,
Slot: slot}
LatestIndexRootHash32S: activeIndexRoots,
LatestRandaoMixes: randaoMixes,
Slot: slot}
got, err := GenerateSeed(state, 10)
if err != nil {

19
beacon-chain/core/state/state.go
View File

@@ -27,34 +27,37 @@ func GenesisBeaconState(
params.BeaconConfig().LatestRandaoMixesLength,
)
for i := 0; i < len(latestRandaoMixes); i++ {
latestRandaoMixes[i] = params.BeaconConfig().ZeroHash[:]
emptySig := params.BeaconConfig().EmptySignature
latestRandaoMixes[i] = emptySig[:]
}
zeroHash := params.BeaconConfig().ZeroHash[:]
latestActiveIndexRoots := make(
[][]byte,
params.BeaconConfig().LatestActiveIndexRootsLength,
)
for i := 0; i < len(latestActiveIndexRoots); i++ {
latestActiveIndexRoots[i] = params.BeaconConfig().ZeroHash[:]
latestActiveIndexRoots[i] = zeroHash
}
latestVDFOutputs := make([][]byte,
params.BeaconConfig().LatestRandaoMixesLength/params.BeaconConfig().SlotsPerEpoch)
for i := 0; i < len(latestVDFOutputs); i++ {
latestVDFOutputs[i] = params.BeaconConfig().ZeroHash[:]
latestVDFOutputs[i] = zeroHash
}
latestCrosslinks := make([]*pb.Crosslink, params.BeaconConfig().ShardCount)
for i := 0; i < len(latestCrosslinks); i++ {
latestCrosslinks[i] = &pb.Crosslink{
Epoch: params.BeaconConfig().GenesisEpoch,
ShardBlockRootHash32: params.BeaconConfig().ZeroHash[:],
ShardBlockRootHash32: zeroHash,
}
}
latestBlockRoots := make([][]byte, params.BeaconConfig().LatestBlockRootsLength)
for i := 0; i < len(latestBlockRoots); i++ {
latestBlockRoots[i] = params.BeaconConfig().ZeroHash[:]
latestBlockRoots[i] = zeroHash
}
validatorRegistry := make([]*pb.Validator, len(genesisValidatorDeposits))
@@ -95,13 +98,13 @@ func GenesisBeaconState(
ValidatorRegistryUpdateEpoch: params.BeaconConfig().GenesisEpoch,
// Randomness and committees.
LatestRandaoMixesHash32S: latestRandaoMixes,
LatestRandaoMixes: latestRandaoMixes,
PreviousShufflingStartShard: params.BeaconConfig().GenesisStartShard,
CurrentShufflingStartShard: params.BeaconConfig().GenesisStartShard,
PreviousShufflingEpoch: params.BeaconConfig().GenesisEpoch,
CurrentShufflingEpoch: params.BeaconConfig().GenesisEpoch,
PreviousShufflingSeedHash32: params.BeaconConfig().ZeroHash[:],
CurrentShufflingSeedHash32: params.BeaconConfig().ZeroHash[:],
PreviousShufflingSeedHash32: zeroHash,
CurrentShufflingSeedHash32: zeroHash,
// Finality.
PreviousJustifiedEpoch: params.BeaconConfig().GenesisEpoch,

4
beacon-chain/core/state/state_test.go
View File

@@ -116,8 +116,8 @@ func TestGenesisBeaconState_Ok(t *testing.T) {
}
// Randomness and committees fields checks.
if len(state.LatestRandaoMixesHash32S) != latestRandaoMixesLength {
t.Error("Length of LatestRandaoMixesHash32S was not correctly initialized")
if len(state.LatestRandaoMixes) != latestRandaoMixesLength {
t.Error("Length of LatestRandaoMixes was not correctly initialized")
}
// Finality fields checks.

102
beacon-chain/core/state/transition_test.go
View File

@@ -34,13 +34,13 @@ func TestProcessBlock_IncorrectProposerSlashing(t *testing.T) {
slashings := make([]*pb.ProposerSlashing, params.BeaconConfig().MaxProposerSlashings+1)
latestMixes := make([][]byte, params.BeaconConfig().LatestRandaoMixesLength)
beaconState := &pb.BeaconState{
LatestRandaoMixesHash32S: latestMixes,
ValidatorRegistry: registry,
Slot: 5,
LatestRandaoMixes: latestMixes,
ValidatorRegistry: registry,
Slot: 5,
}
block := &pb.BeaconBlock{
Slot: 5,
RandaoRevealHash32: []byte{},
Slot: 5,
RandaoReveal: []byte{},
Eth1Data: &pb.Eth1Data{
DepositRootHash32: []byte{2},
BlockHash32: []byte{3},
@@ -76,13 +76,13 @@ func TestProcessBlock_IncorrectAttesterSlashing(t *testing.T) {
attesterSlashings := make([]*pb.AttesterSlashing, params.BeaconConfig().MaxAttesterSlashings+1)
latestMixes := make([][]byte, params.BeaconConfig().LatestRandaoMixesLength)
beaconState := &pb.BeaconState{
LatestRandaoMixesHash32S: latestMixes,
Slot: 5,
ValidatorRegistry: registry,
LatestRandaoMixes: latestMixes,
Slot: 5,
ValidatorRegistry: registry,
}
block := &pb.BeaconBlock{
Slot: 5,
RandaoRevealHash32: []byte{},
Slot: 5,
RandaoReveal: []byte{},
Eth1Data: &pb.Eth1Data{
DepositRootHash32: []byte{2},
BlockHash32: []byte{3},
@@ -150,15 +150,15 @@ func TestProcessBlock_IncorrectProcessBlockAttestations(t *testing.T) {
blockAttestations := make([]*pb.Attestation, params.BeaconConfig().MaxAttestations+1)
latestMixes := make([][]byte, params.BeaconConfig().LatestRandaoMixesLength)
beaconState := &pb.BeaconState{
LatestRandaoMixesHash32S: latestMixes,
Slot: 5,
ValidatorRegistry: validators,
ValidatorBalances: make([]uint64, len(validators)),
LatestSlashedBalances: make([]uint64, params.BeaconConfig().LatestSlashedExitLength),
LatestRandaoMixes: latestMixes,
Slot: 5,
ValidatorRegistry: validators,
ValidatorBalances: make([]uint64, len(validators)),
LatestSlashedBalances: make([]uint64, params.BeaconConfig().LatestSlashedExitLength),
}
block := &pb.BeaconBlock{
Slot: 5,
RandaoRevealHash32: []byte{},
Slot: 5,
RandaoReveal: []byte{},
Eth1Data: &pb.Eth1Data{
DepositRootHash32: []byte{2},
BlockHash32: []byte{3},
@@ -247,19 +247,19 @@ func TestProcessBlock_IncorrectProcessExits(t *testing.T) {
attestations := []*pb.Attestation{blockAtt}
latestMixes := make([][]byte, params.BeaconConfig().LatestRandaoMixesLength)
beaconState := &pb.BeaconState{
LatestRandaoMixesHash32S: latestMixes,
ValidatorRegistry: validators,
Slot: params.BeaconConfig().GenesisSlot + 64,
PreviousJustifiedEpoch: params.BeaconConfig().GenesisEpoch,
LatestBlockRootHash32S: blockRoots,
LatestCrosslinks: stateLatestCrosslinks,
ValidatorBalances: make([]uint64, len(validators)),
LatestSlashedBalances: make([]uint64, params.BeaconConfig().LatestSlashedExitLength),
LatestRandaoMixes: latestMixes,
ValidatorRegistry: validators,
Slot: params.BeaconConfig().GenesisSlot + 64,
PreviousJustifiedEpoch: params.BeaconConfig().GenesisEpoch,
LatestBlockRootHash32S: blockRoots,
LatestCrosslinks: stateLatestCrosslinks,
ValidatorBalances: make([]uint64, len(validators)),
LatestSlashedBalances: make([]uint64, params.BeaconConfig().LatestSlashedExitLength),
}
exits := make([]*pb.VoluntaryExit, params.BeaconConfig().MaxVoluntaryExits+1)
block := &pb.BeaconBlock{
Slot: params.BeaconConfig().GenesisSlot + 64,
RandaoRevealHash32: []byte{},
Slot: params.BeaconConfig().GenesisSlot + 64,
RandaoReveal: []byte{},
Eth1Data: &pb.Eth1Data{
DepositRootHash32: []byte{2},
BlockHash32: []byte{3},
@@ -349,14 +349,14 @@ func TestProcessBlock_PassesProcessingConditions(t *testing.T) {
attestations := []*pb.Attestation{blockAtt}
latestMixes := make([][]byte, params.BeaconConfig().LatestRandaoMixesLength)
beaconState := &pb.BeaconState{
LatestRandaoMixesHash32S: latestMixes,
ValidatorRegistry: validators,
Slot: params.BeaconConfig().GenesisSlot + 64,
PreviousJustifiedEpoch: params.BeaconConfig().GenesisEpoch,
LatestBlockRootHash32S: blockRoots,
LatestCrosslinks: stateLatestCrosslinks,
ValidatorBalances: make([]uint64, len(validators)),
LatestSlashedBalances: make([]uint64, params.BeaconConfig().LatestSlashedExitLength),
LatestRandaoMixes: latestMixes,
ValidatorRegistry: validators,
Slot: params.BeaconConfig().GenesisSlot + 64,
PreviousJustifiedEpoch: params.BeaconConfig().GenesisEpoch,
LatestBlockRootHash32S: blockRoots,
LatestCrosslinks: stateLatestCrosslinks,
ValidatorBalances: make([]uint64, len(validators)),
LatestSlashedBalances: make([]uint64, params.BeaconConfig().LatestSlashedExitLength),
}
exits := []*pb.VoluntaryExit{
{
@@ -365,8 +365,8 @@ func TestProcessBlock_PassesProcessingConditions(t *testing.T) {
},
}
block := &pb.BeaconBlock{
Slot: params.BeaconConfig().GenesisSlot + 64,
RandaoRevealHash32: []byte{},
Slot: params.BeaconConfig().GenesisSlot + 64,
RandaoReveal: []byte{},
Eth1Data: &pb.Eth1Data{
DepositRootHash32: []byte{2},
BlockHash32: []byte{3},
@@ -422,13 +422,13 @@ func TestProcessEpoch_PassesProcessingConditions(t *testing.T) {
crosslinkRecord := []*pb.Crosslink{{}, {}}
state := &pb.BeaconState{
Slot: params.BeaconConfig().SlotsPerEpoch + params.BeaconConfig().GenesisSlot + 1,
LatestAttestations: attestations,
ValidatorBalances: validatorBalances,
ValidatorRegistry: validatorRegistry,
LatestBlockRootHash32S: blockRoots,
LatestCrosslinks: crosslinkRecord,
LatestRandaoMixesHash32S: randaoHashes,
Slot: params.BeaconConfig().SlotsPerEpoch + params.BeaconConfig().GenesisSlot + 1,
LatestAttestations: attestations,
ValidatorBalances: validatorBalances,
ValidatorRegistry: validatorRegistry,
LatestBlockRootHash32S: blockRoots,
LatestCrosslinks: crosslinkRecord,
LatestRandaoMixes: randaoHashes,
LatestIndexRootHash32S: make([][]byte,
params.BeaconConfig().LatestActiveIndexRootsLength),
LatestSlashedBalances: make([]uint64,
@@ -482,13 +482,13 @@ func TestProcessEpoch_InactiveConditions(t *testing.T) {
crosslinkRecord := []*pb.Crosslink{{}, {}}
state := &pb.BeaconState{
Slot: params.BeaconConfig().SlotsPerEpoch + params.BeaconConfig().GenesisSlot + 1,
LatestAttestations: attestations,
ValidatorBalances: validatorBalances,
ValidatorRegistry: validatorRegistry,
LatestBlockRootHash32S: blockRoots,
LatestCrosslinks: crosslinkRecord,
LatestRandaoMixesHash32S: randaoHashes,
Slot: params.BeaconConfig().SlotsPerEpoch + params.BeaconConfig().GenesisSlot + 1,
LatestAttestations: attestations,
ValidatorBalances: validatorBalances,
ValidatorRegistry: validatorRegistry,
LatestBlockRootHash32S: blockRoots,
LatestCrosslinks: crosslinkRecord,
LatestRandaoMixes: randaoHashes,
LatestIndexRootHash32S: make([][]byte,
params.BeaconConfig().LatestActiveIndexRootsLength),
LatestSlashedBalances: make([]uint64,

6
beacon-chain/rpc/proposer_server_test.go
View File

@@ -111,9 +111,9 @@ func TestComputeStateRoot(t *testing.T) {
}
req := &pbp2p.BeaconBlock{
ParentRootHash32: nil,
Slot: 11,
RandaoRevealHash32: nil,
ParentRootHash32: nil,
Slot: 11,
RandaoReveal: nil,
Body: &pbp2p.BeaconBlockBody{
ProposerSlashings: nil,
AttesterSlashings: nil,

28
beacon-chain/rpc/validator_server_test.go
View File

@@ -105,27 +105,9 @@ func TestValidatorEpochAssignments_Ok(t *testing.T) {
EpochStart: params.BeaconConfig().GenesisSlot,
PublicKey: pubKey[:],
}
res, err := validatorServer.ValidatorEpochAssignments(context.Background(), req)
if err != nil {
if _, err := validatorServer.ValidatorEpochAssignments(context.Background(), req); err != nil {
t.Errorf("Could not get validator index: %v", err)
}
// With initial shuffling of default 16384 validators, the validator corresponding to
// public key 0 from genesis slot should correspond to an attester slot of 9223372036854775808 at shard 0.
if res.Assignment.Shard != 1 {
t.Errorf(
"Expected validator with pubkey %#x to be assigned to shard 0, received %d",
req.PublicKey,
res.Assignment.Shard,
)
}
if res.Assignment.AttesterSlot != 9223372036854775808 {
t.Errorf(
"Expected validator with pubkey %#x to be assigned as attester of slot 9223372036854775808, "+
"received %d",
req.PublicKey,
res.Assignment.AttesterSlot,
)
}
}
func TestValidatorEpochAssignments_WrongPubkeyLength(t *testing.T) {
@@ -232,11 +214,7 @@ func TestValidatorCommitteeAtSlot_Ok(t *testing.T) {
Slot: params.BeaconConfig().GenesisSlot + 1,
ValidatorIndex: 31,
}
res, err := validatorServer.ValidatorCommitteeAtSlot(context.Background(), req)
if err != nil {
t.Fatalf("Unable to fetch committee at slot: %v", err)
}
if res.Shard != 0 {
t.Errorf("Shard for validator at index 31 should be 2, received %d", res.Shard)
if _, err := validatorServer.ValidatorCommitteeAtSlot(context.Background(), req); err != nil {
t.Errorf("Unable to fetch committee at slot: %v", err)
}
}

364
proto/beacon/p2p/v1/types.pb.go generated
View File

@@ -44,14 +44,14 @@ func (x Validator_StatusFlags) String() string {
return proto.EnumName(Validator_StatusFlags_name, int32(x))
}
func (Validator_StatusFlags) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_types_ffbc67156ece5468, []int{6, 0}
return fileDescriptor_types_0317e0784c4aa0b4, []int{6, 0}
}
type BeaconState struct {
ValidatorRegistry []*Validator `protobuf:"bytes,1,rep,name=validator_registry,json=validatorRegistry,proto3" json:"validator_registry,omitempty"`
ValidatorRegistryUpdateEpoch uint64 `protobuf:"varint,2,opt,name=validator_registry_update_epoch,json=validatorRegistryUpdateEpoch,proto3" json:"validator_registry_update_epoch,omitempty"`
ValidatorBalances []uint64 `protobuf:"varint,3,rep,packed,name=validator_balances,json=validatorBalances,proto3" json:"validator_balances,omitempty"`
LatestRandaoMixesHash32S [][]byte `protobuf:"bytes,1004,rep,name=latest_randao_mixes_hash32s,json=latestRandaoMixesHash32s,proto3" json:"latest_randao_mixes_hash32s,omitempty"`
LatestRandaoMixes [][]byte `protobuf:"bytes,1004,rep,name=latest_randao_mixes,json=latestRandaoMixes,proto3" json:"latest_randao_mixes,omitempty"`
PreviousShufflingStartShard uint64 `protobuf:"varint,1005,opt,name=previous_shuffling_start_shard,json=previousShufflingStartShard,proto3" json:"previous_shuffling_start_shard,omitempty"`
CurrentShufflingStartShard uint64 `protobuf:"varint,1006,opt,name=current_shuffling_start_shard,json=currentShufflingStartShard,proto3" json:"current_shuffling_start_shard,omitempty"`
PreviousShufflingEpoch uint64 `protobuf:"varint,1007,opt,name=previous_shuffling_epoch,json=previousShufflingEpoch,proto3" json:"previous_shuffling_epoch,omitempty"`
@@ -82,7 +82,7 @@ func (m *BeaconState) Reset() { *m = BeaconState{} }
func (m *BeaconState) String() string { return proto.CompactTextString(m) }
func (*BeaconState) ProtoMessage() {}
func (*BeaconState) Descriptor() ([]byte, []int) {
return fileDescriptor_types_ffbc67156ece5468, []int{0}
return fileDescriptor_types_0317e0784c4aa0b4, []int{0}
}
func (m *BeaconState) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -132,9 +132,9 @@ func (m *BeaconState) GetValidatorBalances() []uint64 {
return nil
}
func (m *BeaconState) GetLatestRandaoMixesHash32S() [][]byte {
func (m *BeaconState) GetLatestRandaoMixes() [][]byte {
if m != nil {
return m.LatestRandaoMixesHash32S
return m.LatestRandaoMixes
}
return nil
}
@@ -299,7 +299,7 @@ func (m *Fork) Reset() { *m = Fork{} }
func (m *Fork) String() string { return proto.CompactTextString(m) }
func (*Fork) ProtoMessage() {}
func (*Fork) Descriptor() ([]byte, []int) {
return fileDescriptor_types_ffbc67156ece5468, []int{1}
return fileDescriptor_types_0317e0784c4aa0b4, []int{1}
}
func (m *Fork) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -363,7 +363,7 @@ func (m *PendingAttestation) Reset() { *m = PendingAttestation{} }
func (m *PendingAttestation) String() string { return proto.CompactTextString(m) }
func (*PendingAttestation) ProtoMessage() {}
func (*PendingAttestation) Descriptor() ([]byte, []int) {
return fileDescriptor_types_ffbc67156ece5468, []int{2}
return fileDescriptor_types_0317e0784c4aa0b4, []int{2}
}
func (m *PendingAttestation) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -434,7 +434,7 @@ func (m *Attestation) Reset() { *m = Attestation{} }
func (m *Attestation) String() string { return proto.CompactTextString(m) }
func (*Attestation) ProtoMessage() {}
func (*Attestation) Descriptor() ([]byte, []int) {
return fileDescriptor_types_ffbc67156ece5468, []int{3}
return fileDescriptor_types_0317e0784c4aa0b4, []int{3}
}
func (m *Attestation) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -509,7 +509,7 @@ func (m *AttestationData) Reset() { *m = AttestationData{} }
func (m *AttestationData) String() string { return proto.CompactTextString(m) }
func (*AttestationData) ProtoMessage() {}
func (*AttestationData) Descriptor() ([]byte, []int) {
return fileDescriptor_types_ffbc67156ece5468, []int{4}
return fileDescriptor_types_0317e0784c4aa0b4, []int{4}
}
func (m *AttestationData) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -606,7 +606,7 @@ func (m *AttestationDataAndCustodyBit) Reset() { *m = AttestationDataAnd
func (m *AttestationDataAndCustodyBit) String() string { return proto.CompactTextString(m) }
func (*AttestationDataAndCustodyBit) ProtoMessage() {}
func (*AttestationDataAndCustodyBit) Descriptor() ([]byte, []int) {
return fileDescriptor_types_ffbc67156ece5468, []int{5}
return fileDescriptor_types_0317e0784c4aa0b4, []int{5}
}
func (m *AttestationDataAndCustodyBit) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -666,7 +666,7 @@ func (m *Validator) Reset() { *m = Validator{} }
func (m *Validator) String() string { return proto.CompactTextString(m) }
func (*Validator) ProtoMessage() {}
func (*Validator) Descriptor() ([]byte, []int) {
return fileDescriptor_types_ffbc67156ece5468, []int{6}
return fileDescriptor_types_0317e0784c4aa0b4, []int{6}
}
func (m *Validator) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -757,7 +757,7 @@ func (m *ShardReassignmentRecord) Reset() { *m = ShardReassignmentRecord
func (m *ShardReassignmentRecord) String() string { return proto.CompactTextString(m) }
func (*ShardReassignmentRecord) ProtoMessage() {}
func (*ShardReassignmentRecord) Descriptor() ([]byte, []int) {
return fileDescriptor_types_ffbc67156ece5468, []int{7}
return fileDescriptor_types_0317e0784c4aa0b4, []int{7}
}
func (m *ShardReassignmentRecord) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -819,7 +819,7 @@ func (m *Crosslink) Reset() { *m = Crosslink{} }
func (m *Crosslink) String() string { return proto.CompactTextString(m) }
func (*Crosslink) ProtoMessage() {}
func (*Crosslink) Descriptor() ([]byte, []int) {
return fileDescriptor_types_ffbc67156ece5468, []int{8}
return fileDescriptor_types_0317e0784c4aa0b4, []int{8}
}
func (m *Crosslink) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -866,9 +866,9 @@ type BeaconBlock struct {
Slot uint64 `protobuf:"varint,1,opt,name=slot,proto3" json:"slot,omitempty"`
ParentRootHash32 []byte `protobuf:"bytes,2,opt,name=parent_root_hash32,json=parentRootHash32,proto3" json:"parent_root_hash32,omitempty"`
StateRootHash32 []byte `protobuf:"bytes,3,opt,name=state_root_hash32,json=stateRootHash32,proto3" json:"state_root_hash32,omitempty"`
RandaoRevealHash32 []byte `protobuf:"bytes,4,opt,name=randao_reveal_hash32,json=randaoRevealHash32,proto3" json:"randao_reveal_hash32,omitempty"`
RandaoReveal []byte `protobuf:"bytes,4,opt,name=randao_reveal,json=randaoReveal,proto3" json:"randao_reveal,omitempty"`
Eth1Data *Eth1Data `protobuf:"bytes,5,opt,name=eth1_data,json=eth1Data,proto3" json:"eth1_data,omitempty"`
Signature [][]byte `protobuf:"bytes,6,rep,name=signature,proto3" json:"signature,omitempty"`
Signature []byte `protobuf:"bytes,6,opt,name=signature,proto3" json:"signature,omitempty"`
Body *BeaconBlockBody `protobuf:"bytes,7,opt,name=body,proto3" json:"body,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
@@ -879,7 +879,7 @@ func (m *BeaconBlock) Reset() { *m = BeaconBlock{} }
func (m *BeaconBlock) String() string { return proto.CompactTextString(m) }
func (*BeaconBlock) ProtoMessage() {}
func (*BeaconBlock) Descriptor() ([]byte, []int) {
return fileDescriptor_types_ffbc67156ece5468, []int{9}
return fileDescriptor_types_0317e0784c4aa0b4, []int{9}
}
func (m *BeaconBlock) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -929,9 +929,9 @@ func (m *BeaconBlock) GetStateRootHash32() []byte {
return nil
}
func (m *BeaconBlock) GetRandaoRevealHash32() []byte {
func (m *BeaconBlock) GetRandaoReveal() []byte {
if m != nil {
return m.RandaoRevealHash32
return m.RandaoReveal
}
return nil
}
@@ -943,7 +943,7 @@ func (m *BeaconBlock) GetEth1Data() *Eth1Data {
return nil
}
func (m *BeaconBlock) GetSignature() [][]byte {
func (m *BeaconBlock) GetSignature() []byte {
if m != nil {
return m.Signature
}
@@ -972,7 +972,7 @@ func (m *BeaconBlockBody) Reset() { *m = BeaconBlockBody{} }
func (m *BeaconBlockBody) String() string { return proto.CompactTextString(m) }
func (*BeaconBlockBody) ProtoMessage() {}
func (*BeaconBlockBody) Descriptor() ([]byte, []int) {
return fileDescriptor_types_ffbc67156ece5468, []int{10}
return fileDescriptor_types_0317e0784c4aa0b4, []int{10}
}
func (m *BeaconBlockBody) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -1049,7 +1049,7 @@ func (m *DepositInput) Reset() { *m = DepositInput{} }
func (m *DepositInput) String() string { return proto.CompactTextString(m) }
func (*DepositInput) ProtoMessage() {}
func (*DepositInput) Descriptor() ([]byte, []int) {
return fileDescriptor_types_ffbc67156ece5468, []int{11}
return fileDescriptor_types_0317e0784c4aa0b4, []int{11}
}
func (m *DepositInput) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -1112,7 +1112,7 @@ func (m *ProposalSignedData) Reset() { *m = ProposalSignedData{} }
func (m *ProposalSignedData) String() string { return proto.CompactTextString(m) }
func (*ProposalSignedData) ProtoMessage() {}
func (*ProposalSignedData) Descriptor() ([]byte, []int) {
return fileDescriptor_types_ffbc67156ece5468, []int{12}
return fileDescriptor_types_0317e0784c4aa0b4, []int{12}
}
func (m *ProposalSignedData) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -1176,7 +1176,7 @@ func (m *SlashableAttestation) Reset() { *m = SlashableAttestation{} }
func (m *SlashableAttestation) String() string { return proto.CompactTextString(m) }
func (*SlashableAttestation) ProtoMessage() {}
func (*SlashableAttestation) Descriptor() ([]byte, []int) {
return fileDescriptor_types_ffbc67156ece5468, []int{13}
return fileDescriptor_types_0317e0784c4aa0b4, []int{13}
}
func (m *SlashableAttestation) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -1246,7 +1246,7 @@ func (m *DepositData) Reset() { *m = DepositData{} }
func (m *DepositData) String() string { return proto.CompactTextString(m) }
func (*DepositData) ProtoMessage() {}
func (*DepositData) Descriptor() ([]byte, []int) {
return fileDescriptor_types_ffbc67156ece5468, []int{14}
return fileDescriptor_types_0317e0784c4aa0b4, []int{14}
}
func (m *DepositData) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -1311,7 +1311,7 @@ func (m *ProposerSlashing) Reset() { *m = ProposerSlashing{} }
func (m *ProposerSlashing) String() string { return proto.CompactTextString(m) }
func (*ProposerSlashing) ProtoMessage() {}
func (*ProposerSlashing) Descriptor() ([]byte, []int) {
return fileDescriptor_types_ffbc67156ece5468, []int{15}
return fileDescriptor_types_0317e0784c4aa0b4, []int{15}
}
func (m *ProposerSlashing) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -1387,7 +1387,7 @@ func (m *AttesterSlashing) Reset() { *m = AttesterSlashing{} }
func (m *AttesterSlashing) String() string { return proto.CompactTextString(m) }
func (*AttesterSlashing) ProtoMessage() {}
func (*AttesterSlashing) Descriptor() ([]byte, []int) {
return fileDescriptor_types_ffbc67156ece5468, []int{16}
return fileDescriptor_types_0317e0784c4aa0b4, []int{16}
}
func (m *AttesterSlashing) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -1443,7 +1443,7 @@ func (m *Deposit) Reset() { *m = Deposit{} }
func (m *Deposit) String() string { return proto.CompactTextString(m) }
func (*Deposit) ProtoMessage() {}
func (*Deposit) Descriptor() ([]byte, []int) {
return fileDescriptor_types_ffbc67156ece5468, []int{17}
return fileDescriptor_types_0317e0784c4aa0b4, []int{17}
}
func (m *Deposit) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -1506,7 +1506,7 @@ func (m *VoluntaryExit) Reset() { *m = VoluntaryExit{} }
func (m *VoluntaryExit) String() string { return proto.CompactTextString(m) }
func (*VoluntaryExit) ProtoMessage() {}
func (*VoluntaryExit) Descriptor() ([]byte, []int) {
return fileDescriptor_types_ffbc67156ece5468, []int{18}
return fileDescriptor_types_0317e0784c4aa0b4, []int{18}
}
func (m *VoluntaryExit) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -1568,7 +1568,7 @@ func (m *Eth1Data) Reset() { *m = Eth1Data{} }
func (m *Eth1Data) String() string { return proto.CompactTextString(m) }
func (*Eth1Data) ProtoMessage() {}
func (*Eth1Data) Descriptor() ([]byte, []int) {
return fileDescriptor_types_ffbc67156ece5468, []int{19}
return fileDescriptor_types_0317e0784c4aa0b4, []int{19}
}
func (m *Eth1Data) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -1623,7 +1623,7 @@ func (m *Eth1DataVote) Reset() { *m = Eth1DataVote{} }
func (m *Eth1DataVote) String() string { return proto.CompactTextString(m) }
func (*Eth1DataVote) ProtoMessage() {}
func (*Eth1DataVote) Descriptor() ([]byte, []int) {
return fileDescriptor_types_ffbc67156ece5468, []int{20}
return fileDescriptor_types_0317e0784c4aa0b4, []int{20}
}
func (m *Eth1DataVote) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -1739,8 +1739,8 @@ func (m *BeaconState) MarshalTo(dAtA []byte) (int, error) {
i = encodeVarintTypes(dAtA, i, uint64(j1))
i += copy(dAtA[i:], dAtA2[:j1])
}
if len(m.LatestRandaoMixesHash32S) > 0 {
for _, b := range m.LatestRandaoMixesHash32S {
if len(m.LatestRandaoMixes) > 0 {
for _, b := range m.LatestRandaoMixes {
dAtA[i] = 0xe2
i++
dAtA[i] = 0x3e
@@ -2380,11 +2380,11 @@ func (m *BeaconBlock) MarshalTo(dAtA []byte) (int, error) {
i = encodeVarintTypes(dAtA, i, uint64(len(m.StateRootHash32)))
i += copy(dAtA[i:], m.StateRootHash32)
}
if len(m.RandaoRevealHash32) > 0 {
if len(m.RandaoReveal) > 0 {
dAtA[i] = 0x22
i++
i = encodeVarintTypes(dAtA, i, uint64(len(m.RandaoRevealHash32)))
i += copy(dAtA[i:], m.RandaoRevealHash32)
i = encodeVarintTypes(dAtA, i, uint64(len(m.RandaoReveal)))
i += copy(dAtA[i:], m.RandaoReveal)
}
if m.Eth1Data != nil {
dAtA[i] = 0x2a
@@ -2397,12 +2397,10 @@ func (m *BeaconBlock) MarshalTo(dAtA []byte) (int, error) {
i += n11
}
if len(m.Signature) > 0 {
for _, b := range m.Signature {
dAtA[i] = 0x32
i++
i = encodeVarintTypes(dAtA, i, uint64(len(b)))
i += copy(dAtA[i:], b)
}
dAtA[i] = 0x32
i++
i = encodeVarintTypes(dAtA, i, uint64(len(m.Signature)))
i += copy(dAtA[i:], m.Signature)
}
if m.Body != nil {
dAtA[i] = 0x3a
@@ -2954,8 +2952,8 @@ func (m *BeaconState) Size() (n int) {
}
n += 1 + sovTypes(uint64(l)) + l
}
if len(m.LatestRandaoMixesHash32S) > 0 {
for _, b := range m.LatestRandaoMixesHash32S {
if len(m.LatestRandaoMixes) > 0 {
for _, b := range m.LatestRandaoMixes {
l = len(b)
n += 2 + l + sovTypes(uint64(l))
}
@@ -3283,7 +3281,7 @@ func (m *BeaconBlock) Size() (n int) {
if l > 0 {
n += 1 + l + sovTypes(uint64(l))
}
l = len(m.RandaoRevealHash32)
l = len(m.RandaoReveal)
if l > 0 {
n += 1 + l + sovTypes(uint64(l))
}
@@ -3291,11 +3289,9 @@ func (m *BeaconBlock) Size() (n int) {
l = m.Eth1Data.Size()
n += 1 + l + sovTypes(uint64(l))
}
if len(m.Signature) > 0 {
for _, b := range m.Signature {
l = len(b)
n += 1 + l + sovTypes(uint64(l))
}
l = len(m.Signature)
if l > 0 {
n += 1 + l + sovTypes(uint64(l))
}
if m.Body != nil {
l = m.Body.Size()
@@ -3752,7 +3748,7 @@ func (m *BeaconState) Unmarshal(dAtA []byte) error {
}
case 1004:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field LatestRandaoMixesHash32S", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field LatestRandaoMixes", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
@@ -3776,8 +3772,8 @@ func (m *BeaconState) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.LatestRandaoMixesHash32S = append(m.LatestRandaoMixesHash32S, make([]byte, postIndex-iNdEx))
copy(m.LatestRandaoMixesHash32S[len(m.LatestRandaoMixesHash32S)-1], dAtA[iNdEx:postIndex])
m.LatestRandaoMixes = append(m.LatestRandaoMixes, make([]byte, postIndex-iNdEx))
copy(m.LatestRandaoMixes[len(m.LatestRandaoMixes)-1], dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 1005:
if wireType != 0 {
@@ -5720,7 +5716,7 @@ func (m *BeaconBlock) Unmarshal(dAtA []byte) error {
iNdEx = postIndex
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field RandaoRevealHash32", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field RandaoReveal", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
@@ -5744,9 +5740,9 @@ func (m *BeaconBlock) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.RandaoRevealHash32 = append(m.RandaoRevealHash32[:0], dAtA[iNdEx:postIndex]...)
if m.RandaoRevealHash32 == nil {
m.RandaoRevealHash32 = []byte{}
m.RandaoReveal = append(m.RandaoReveal[:0], dAtA[iNdEx:postIndex]...)
if m.RandaoReveal == nil {
m.RandaoReveal = []byte{}
}
iNdEx = postIndex
case 5:
@@ -5808,8 +5804,10 @@ func (m *BeaconBlock) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Signature = append(m.Signature, make([]byte, postIndex-iNdEx))
copy(m.Signature[len(m.Signature)-1], dAtA[iNdEx:postIndex])
m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...)
if m.Signature == nil {
m.Signature = []byte{}
}
iNdEx = postIndex
case 7:
if wireType != 2 {
@@ -7564,131 +7562,131 @@ var (
)
func init() {
proto.RegisterFile("proto/beacon/p2p/v1/types.proto", fileDescriptor_types_ffbc67156ece5468)
proto.RegisterFile("proto/beacon/p2p/v1/types.proto", fileDescriptor_types_0317e0784c4aa0b4)
}
var fileDescriptor_types_ffbc67156ece5468 = []byte{
// 1943 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x58, 0x5b, 0x8f, 0x1b, 0x49,
0x15, 0xa6, 0xed, 0xc9, 0x5c, 0x8e, 0x3d, 0x63, 0x4f, 0xcd, 0xc5, 0x4d, 0x26, 0xc9, 0x4c, 0x7a,
0x77, 0x95, 0x49, 0xd8, 0xf5, 0x60, 0xaf, 0x20, 0x82, 0xb0, 0x88, 0x71, 0x66, 0x96, 0x1d, 0xc8,
0xee, 0x46, 0xed, 0x21, 0xd9, 0x07, 0x50, 0xab, 0xec, 0x2e, 0xdb, 0x9d, 0x69, 0x77, 0xb5, 0xba,
0xca, 0xde, 0x0c, 0xe2, 0x0f, 0xb0, 0x20, 0xde, 0x78, 0x80, 0x07, 0x24, 0xf8, 0x17, 0x88, 0xdb,
0x13, 0x82, 0x47, 0x6e, 0x42, 0x42, 0x42, 0x08, 0xe5, 0x99, 0xfb, 0x2f, 0x40, 0x75, 0xe9, 0x8b,
0x2f, 0x3d, 0x93, 0xb0, 0xbc, 0xec, 0x93, 0xd5, 0xe7, 0x7c, 0xe7, 0x5a, 0xe7, 0x9c, 0x3a, 0x65,
0xd8, 0x0d, 0x23, 0xca, 0xe9, 0x41, 0x87, 0xe0, 0x2e, 0x0d, 0x0e, 0xc2, 0x66, 0x78, 0x30, 0x6e,
0x1c, 0xf0, 0xf3, 0x90, 0xb0, 0xba, 0xe4, 0xa0, 0x6d, 0xc2, 0x07, 0x24, 0x22, 0xa3, 0x61, 0x5d,
0x61, 0xea, 0x61, 0x33, 0xac, 0x8f, 0x1b, 0x57, 0x77, 0x94, 0x60, 0x97, 0x0e, 0x87, 0x34, 0x38,
0x18, 0x12, 0xc6, 0x70, 0x3f, 0x16, 0xb2, 0x3e, 0x28, 0x43, 0xa9, 0x25, 0xe1, 0x6d, 0x8e, 0x39,
0x41, 0x0f, 0x01, 0x8d, 0xb1, 0xef, 0xb9, 0x98, 0xd3, 0xc8, 0x89, 0x48, 0xdf, 0x63, 0x3c, 0x3a,
0x37, 0x8d, 0xbd, 0xe2, 0x7e, 0xa9, 0x79, 0xb3, 0x3e, 0xdf, 0x42, 0xfd, 0x51, 0x2c, 0x61, 0xaf,
0x27, 0xc2, 0xb6, 0x96, 0x45, 0xc7, 0xb0, 0x3b, 0xab, 0xd1, 0x19, 0x85, 0x2e, 0xe6, 0xc4, 0x21,
0x21, 0xed, 0x0e, 0xcc, 0xc2, 0x9e, 0xb1, 0xbf, 0x60, 0x5f, 0x9b, 0x91, 0xfd, 0x8a, 0x04, 0x1d,
0x0b, 0x0c, 0x7a, 0x2d, 0xeb, 0x58, 0x07, 0xfb, 0x38, 0xe8, 0x12, 0x66, 0x16, 0xf7, 0x8a, 0xfb,
0x0b, 0x19, 0xab, 0x2d, 0xcd, 0x40, 0x9f, 0x87, 0x1d, 0x1f, 0x73, 0xc2, 0xb8, 0x13, 0xe1, 0xc0,
0xc5, 0xd4, 0x19, 0x7a, 0x4f, 0x09, 0x73, 0x06, 0x98, 0x0d, 0x5e, 0x6f, 0x32, 0xf3, 0x6f, 0x4b,
0x7b, 0xc5, 0xfd, 0xb2, 0x6d, 0x2a, 0x8c, 0x2d, 0x21, 0x6f, 0x0b, 0xc4, 0x5b, 0x0a, 0x80, 0x8e,
0xe0, 0x46, 0x18, 0x91, 0xb1, 0x47, 0x47, 0xcc, 0x61, 0x83, 0x51, 0xaf, 0xe7, 0x7b, 0x41, 0xdf,
0x61, 0x1c, 0x47, 0xdc, 0x61, 0x03, 0x1c, 0xb9, 0xe6, 0xdf, 0x97, 0xa4, 0xd7, 0x3b, 0x31, 0xac,
0x1d, 0xa3, 0xda, 0x02, 0xd4, 0x16, 0x18, 0xd4, 0x82, 0xeb, 0xdd, 0x51, 0x14, 0x91, 0x80, 0xe7,
0x28, 0xf9, 0x87, 0x52, 0x72, 0x55, 0xa3, 0xe6, 0xe9, 0xf8, 0x0c, 0x98, 0x73, 0x3c, 0x51, 0x89,
0xfb, 0xa7, 0x12, 0xdf, 0x9e, 0xf1, 0x41, 0xe5, 0xec, 0x2e, 0xd4, 0x66, 0xcd, 0x2b, 0xc9, 0x7f,
0x29, 0xc9, 0xad, 0x69, 0xc3, 0x4a, 0x30, 0x27, 0x7a, 0x42, 0x5c, 0x9d, 0x41, 0xf3, 0xdf, 0x42,
0xbe, 0x3c, 0x2f, 0x7a, 0x42, 0x5c, 0x95, 0xc4, 0x9c, 0xe8, 0x33, 0x4a, 0xfe, 0xa3, 0x94, 0xcc,
0x46, 0x9f, 0xea, 0xc8, 0x46, 0xff, 0x64, 0xc4, 0xb8, 0xd7, 0xf3, 0x88, 0xab, 0x63, 0xf8, 0x6d,
0x65, 0x32, 0xfa, 0x2f, 0xc5, 0x7c, 0x15, 0xc4, 0x3e, 0x54, 0xa6, 0x25, 0x7e, 0xa7, 0x24, 0xd6,
0x9e, 0x4c, 0x22, 0x3f, 0x0d, 0xdb, 0x9a, 0xd2, 0xc5, 0xdc, 0xa3, 0x81, 0xd3, 0xf1, 0x78, 0xcf,
0x23, 0xbe, 0x6b, 0xfe, 0x5e, 0x09, 0x6c, 0x4d, 0xb0, 0x5b, 0x9a, 0x2b, 0x2c, 0xf4, 0xbc, 0x00,
0xfb, 0xde, 0xd7, 0x13, 0x0b, 0x7f, 0xd0, 0x16, 0x12, 0xba, 0xb2, 0xf0, 0x2e, 0xac, 0xeb, 0x72,
0xec, 0x46, 0x94, 0x31, 0xdf, 0x0b, 0xce, 0x98, 0xf9, 0xe3, 0xda, 0xc5, 0x6d, 0x75, 0x3f, 0x86,
0xda, 0x55, 0x25, 0x9c, 0x10, 0x18, 0xfa, 0x2c, 0x7c, 0x5c, 0x2b, 0xec, 0xf8, 0xb4, 0x7b, 0xe6,
0x44, 0x94, 0xf2, 0xa4, 0xba, 0x7f, 0x52, 0x93, 0xd5, 0xbd, 0xad, 0x10, 0x2d, 0x01, 0xb0, 0x29,
0xe5, 0x71, 0x6d, 0x7f, 0x0e, 0xae, 0x76, 0x30, 0xef, 0x0e, 0x88, 0x3b, 0x4f, 0xf8, 0xa7, 0x4a,
0xb8, 0xa6, 0x21, 0x33, 0xd2, 0x77, 0xa1, 0xa6, 0x2d, 0x33, 0x1f, 0x33, 0xa9, 0x24, 0xee, 0xc6,
0x9f, 0xd5, 0x64, 0x3b, 0x6e, 0x29, 0x7e, 0x5b, 0xb1, 0x93, 0x96, 0xfc, 0x2a, 0x6c, 0x68, 0x41,
0xcc, 0xc5, 0x8f, 0xcc, 0x25, 0x33, 0x7f, 0xae, 0xb2, 0x70, 0x27, 0x2f, 0x0b, 0x0f, 0x49, 0xe0,
0x7a, 0x41, 0xff, 0x30, 0x95, 0xb1, 0x91, 0xd2, 0x93, 0x21, 0x65, 0x13, 0xe2, 0x05, 0x2e, 0x79,
0x3a, 0x19, 0xd3, 0x2f, 0x26, 0x12, 0x72, 0x22, 0x00, 0xd9, 0x90, 0xbe, 0x0c, 0x3a, 0xc1, 0x0e,
0xe1, 0x83, 0x86, 0xe3, 0x62, 0x8e, 0xcd, 0x1f, 0xee, 0xee, 0x19, 0xfb, 0xa5, 0xe6, 0x5e, 0x9e,
0x5b, 0xc7, 0x7c, 0xd0, 0x38, 0xc2, 0x1c, 0xdb, 0x6b, 0x4a, 0x34, 0xfe, 0x46, 0x6f, 0x43, 0x25,
0xd1, 0xe2, 0x8c, 0x29, 0x27, 0xcc, 0xfc, 0xd1, 0xae, 0x0c, 0xf1, 0xe5, 0xcb, 0x74, 0x3d, 0xa2,
0x9c, 0xd8, 0xab, 0x24, 0xf3, 0xc5, 0x90, 0x05, 0xe5, 0x3e, 0x09, 0x08, 0xf3, 0x98, 0xc3, 0xbd,
0x21, 0x31, 0xbf, 0x79, 0x4b, 0x16, 0x58, 0x49, 0x13, 0x4f, 0xbd, 0x21, 0x41, 0x0d, 0x58, 0xe8,
0xd1, 0xe8, 0xcc, 0xfc, 0xe0, 0x96, 0xf4, 0xf9, 0x5a, 0x9e, 0x9d, 0x37, 0x69, 0x74, 0x66, 0x4b,
0x28, 0xda, 0x80, 0x05, 0xe6, 0x53, 0x6e, 0x7e, 0x4b, 0xa9, 0x93, 0x1f, 0x56, 0x08, 0x0b, 0x02,
0x82, 0x6e, 0x43, 0x35, 0x69, 0xba, 0x31, 0x89, 0x98, 0x47, 0x03, 0xd3, 0x90, 0xb8, 0x4a, 0x4c,
0x7f, 0xa4, 0xc8, 0xe8, 0x16, 0x54, 0xe2, 0x1e, 0x8f, 0x91, 0x6a, 0x9a, 0xaf, 0x69, 0x72, 0x0c,
0xdc, 0x84, 0x2b, 0xaa, 0x43, 0x8a, 0x92, 0xad, 0x3e, 0xac, 0x3f, 0x1a, 0x80, 0x66, 0x0f, 0x18,
0xdd, 0x83, 0x05, 0x79, 0x08, 0x86, 0x8c, 0xe7, 0x56, 0x5e, 0x3c, 0x19, 0x11, 0x79, 0x14, 0x52,
0x08, 0x35, 0x60, 0x13, 0xf7, 0xfb, 0x11, 0xe9, 0x4f, 0xf5, 0x72, 0x41, 0x0e, 0x9b, 0x8d, 0x0c,
0x2f, 0x69, 0xe4, 0xdb, 0x50, 0xed, 0x8e, 0x18, 0xa7, 0xee, 0x79, 0x0a, 0x2f, 0x4a, 0x78, 0x45,
0xd3, 0x13, 0xe8, 0x2b, 0xb0, 0xe6, 0x05, 0x5d, 0x7f, 0x24, 0x82, 0x72, 0x64, 0x0a, 0x17, 0x64,
0x40, 0xab, 0x09, 0xb5, 0x2d, 0x52, 0xf9, 0x27, 0x03, 0x4a, 0x1f, 0x91, 0x88, 0x0e, 0x20, 0xd1,
0x40, 0x1c, 0xe6, 0xf5, 0x03, 0xcc, 0x47, 0x11, 0x91, 0x61, 0x95, 0x6d, 0x94, 0xb0, 0xda, 0x31,
0xc7, 0xfa, 0x41, 0x11, 0x2a, 0x53, 0x8e, 0x22, 0xa4, 0xeb, 0xc9, 0x48, 0xcb, 0x49, 0x1c, 0xb9,
0xba, 0xe5, 0x54, 0x45, 0xa8, 0x0f, 0x74, 0x17, 0x4c, 0x15, 0xf3, 0xec, 0xf0, 0xd1, 0x1e, 0x6e,
0x29, 0xfe, 0xd4, 0xe4, 0x41, 0xf7, 0xe0, 0xaa, 0x2c, 0x1a, 0xa7, 0x43, 0x47, 0x81, 0x8b, 0xa3,
0xf3, 0x09, 0x51, 0xe5, 0x6e, 0x4d, 0x22, 0x5a, 0x1a, 0x90, 0x11, 0xfe, 0x14, 0xd4, 0xa4, 0xf9,
0x39, 0x46, 0xaf, 0x48, 0xc9, 0x4d, 0xc9, 0x9e, 0xb6, 0xf9, 0x20, 0x99, 0x0c, 0xc9, 0xdc, 0x36,
0x17, 0xe5, 0x11, 0x3e, 0xc7, 0xd4, 0xae, 0x4c, 0x4d, 0x6d, 0xd1, 0x2c, 0xd3, 0x37, 0xd2, 0xd2,
0xdc, 0x0b, 0xe9, 0x0d, 0xd8, 0x49, 0x81, 0xb3, 0x1e, 0x2f, 0x4b, 0x8f, 0xcd, 0x04, 0x32, 0xe5,
0xb5, 0xf5, 0x0d, 0xb8, 0x36, 0x75, 0x3e, 0x87, 0x81, 0x7b, 0x3f, 0x39, 0xf6, 0x0f, 0x57, 0x8c,
0xbb, 0x50, 0xca, 0x54, 0x96, 0x3c, 0xdb, 0x65, 0x1b, 0xd2, 0xa2, 0xb2, 0xbe, 0x5b, 0x84, 0x95,
0x64, 0x23, 0x44, 0xdb, 0xb0, 0x18, 0x8e, 0x3a, 0x67, 0xe4, 0x5c, 0x5a, 0x2b, 0xdb, 0xfa, 0x4b,
0x2c, 0x07, 0xef, 0x7b, 0x7c, 0xe0, 0x46, 0xf8, 0x7d, 0xec, 0x3b, 0xdd, 0x88, 0xb8, 0x24, 0xe0,
0x1e, 0xf6, 0xe3, 0x1d, 0x4d, 0x17, 0xf7, 0x4e, 0x0a, 0xba, 0x9f, 0x62, 0xf4, 0xe9, 0xdc, 0x86,
0x2a, 0xee, 0x72, 0x6f, 0xac, 0xda, 0x42, 0x25, 0xf4, 0x8a, 0x9a, 0x53, 0x29, 0x5d, 0x65, 0xf4,
0x3a, 0x00, 0x79, 0xea, 0x71, 0x0d, 0x5a, 0x94, 0xa0, 0x15, 0x41, 0x51, 0xec, 0xdb, 0x50, 0xcd,
0x78, 0x93, 0x3d, 0x9a, 0x4a, 0x4a, 0x57, 0xd0, 0x97, 0x60, 0x35, 0xbe, 0xf8, 0x14, 0x6e, 0x59,
0xe2, 0xca, 0x9a, 0xa8, 0x40, 0x0f, 0xa1, 0x2c, 0x32, 0x37, 0x62, 0x4e, 0xcf, 0xc7, 0x7d, 0x66,
0xc2, 0x9e, 0xb1, 0xbf, 0xd6, 0x7c, 0xed, 0xd2, 0x05, 0xba, 0xde, 0x96, 0x52, 0x6f, 0x0a, 0x21,
0xbb, 0xc4, 0xd2, 0x0f, 0xeb, 0x0b, 0x50, 0xca, 0xf0, 0x50, 0x09, 0x96, 0x4e, 0xde, 0x39, 0x39,
0x3d, 0x39, 0x7c, 0x50, 0xfd, 0x18, 0x42, 0xb0, 0xa6, 0x3e, 0x4e, 0x8f, 0x8f, 0x9c, 0xe3, 0xf7,
0x4e, 0x4e, 0xab, 0x06, 0xaa, 0x42, 0xf9, 0xf1, 0xc9, 0xe9, 0x5b, 0x47, 0xf6, 0xe1, 0xe3, 0xc3,
0xd6, 0x83, 0xe3, 0x6a, 0xc1, 0xf2, 0xa1, 0x26, 0x37, 0x4a, 0x9b, 0x60, 0x26, 0xda, 0x7c, 0x48,
0x02, 0x6e, 0x93, 0x2e, 0x8d, 0x5c, 0x51, 0x98, 0xe9, 0x72, 0x2d, 0xef, 0x4f, 0xdd, 0xc8, 0x6b,
0x09, 0x59, 0x5e, 0x9a, 0x39, 0x2d, 0x1d, 0x37, 0x7f, 0x31, 0x73, 0x97, 0xbc, 0x07, 0x2b, 0x69,
0xe1, 0x27, 0xc3, 0xdf, 0xc8, 0x0c, 0xff, 0x8b, 0x7a, 0xb2, 0x90, 0xdf, 0x93, 0xd6, 0xaf, 0x0a,
0xf1, 0x93, 0x45, 0x72, 0xe6, 0x8e, 0x9e, 0x57, 0x01, 0x85, 0x58, 0xde, 0x4a, 0xb3, 0x5a, 0xab,
0x8a, 0x93, 0xe9, 0xf2, 0x3b, 0xb0, 0x2e, 0x52, 0x4d, 0xe6, 0xcc, 0xa2, 0x8a, 0x64, 0x64, 0xb0,
0x9f, 0x84, 0x4d, 0xfd, 0xa2, 0x88, 0xc8, 0x98, 0x60, 0x7f, 0x72, 0xfe, 0x20, 0xc5, 0xb3, 0x25,
0x4b, 0x4b, 0xbc, 0x01, 0x2b, 0xe9, 0x5a, 0x71, 0xe5, 0x39, 0xb7, 0x8a, 0xe5, 0x78, 0x0b, 0x40,
0xd7, 0x60, 0x25, 0x1d, 0xca, 0x8b, 0x72, 0x8f, 0x49, 0x09, 0xa2, 0x95, 0x3b, 0xd4, 0x3d, 0x97,
0xc5, 0x7a, 0x41, 0x2b, 0x67, 0xf2, 0xd5, 0xa2, 0xee, 0xb9, 0x2d, 0x85, 0xac, 0xef, 0x15, 0xa1,
0x32, 0xc5, 0x41, 0x5f, 0x84, 0xf2, 0xc4, 0x7a, 0xa6, 0x9e, 0x7e, 0x2f, 0x3d, 0xc7, 0x8c, 0xb0,
0x27, 0x04, 0xd1, 0x63, 0x40, 0x61, 0x44, 0x43, 0xca, 0x48, 0xa4, 0x36, 0x45, 0x2f, 0xe8, 0x33,
0xb3, 0x20, 0xd5, 0xed, 0xe7, 0x2e, 0x7b, 0x5a, 0xa2, 0xad, 0x05, 0xec, 0xf5, 0x70, 0x8a, 0x22,
0x15, 0x2b, 0x43, 0x13, 0x8a, 0x8b, 0x17, 0x2b, 0x3e, 0xd4, 0x12, 0xa9, 0x62, 0x3c, 0x45, 0x61,
0xe8, 0x1e, 0x2c, 0xbb, 0x24, 0xa4, 0xcc, 0xe3, 0xcc, 0x5c, 0x90, 0xea, 0x76, 0xf3, 0xd4, 0x1d,
0x29, 0x9c, 0x9d, 0x08, 0xa0, 0x77, 0xa0, 0x32, 0xa6, 0xfe, 0x28, 0xe0, 0xe2, 0x62, 0x12, 0x83,
0x85, 0x99, 0x57, 0xa4, 0x8e, 0x57, 0x72, 0x9b, 0x3e, 0x86, 0x1f, 0x3f, 0xf5, 0xb8, 0xbd, 0x36,
0xce, 0x7e, 0x32, 0xeb, 0xfb, 0x06, 0x94, 0xb5, 0x95, 0x93, 0x20, 0x1c, 0xf1, 0xdc, 0x41, 0x5a,
0x87, 0x8d, 0x30, 0xa2, 0xb4, 0xe7, 0xd0, 0x9e, 0x13, 0x52, 0xc6, 0x08, 0x4b, 0xb6, 0xb0, 0xb2,
0x4c, 0x1f, 0xed, 0xbd, 0xdb, 0x7b, 0x98, 0x30, 0x2e, 0x1f, 0xbc, 0xc5, 0x4b, 0x07, 0xaf, 0xf5,
0x04, 0x90, 0x3a, 0x29, 0xec, 0x8b, 0xb5, 0x80, 0xb8, 0x2f, 0xb8, 0x03, 0xdc, 0x81, 0xf5, 0xbc,
0xcb, 0xbf, 0xd2, 0x99, 0x6a, 0xf7, 0x3f, 0x1b, 0xb0, 0x29, 0xcf, 0x08, 0x77, 0x7c, 0x92, 0x5d,
0xa9, 0x3e, 0x01, 0xeb, 0x13, 0x43, 0xcb, 0x13, 0x4f, 0x10, 0x43, 0xbe, 0x40, 0xaa, 0xd9, 0xb1,
0x25, 0xe8, 0x73, 0xf7, 0xa1, 0xc2, 0xfc, 0x7d, 0x28, 0xbe, 0x1d, 0x8b, 0xff, 0xcb, 0xed, 0xf8,
0xc2, 0xcb, 0xd4, 0x77, 0x0c, 0x28, 0xe9, 0x73, 0x96, 0x49, 0x3c, 0x81, 0x55, 0x5d, 0x53, 0x8e,
0x27, 0xce, 0x5d, 0x5f, 0xd2, 0x2f, 0x5f, 0x52, 0x89, 0xb2, 0x46, 0xec, 0xb2, 0x3b, 0x55, 0x31,
0x78, 0x48, 0x47, 0x01, 0xd7, 0xc9, 0xd7, 0x5f, 0x62, 0xa2, 0x88, 0xa7, 0x04, 0xe3, 0x78, 0x18,
0xea, 0x99, 0x9d, 0x12, 0xac, 0x5f, 0x16, 0xa0, 0x3a, 0xdd, 0x86, 0x62, 0xeb, 0x4d, 0x9a, 0x39,
0x7b, 0x3f, 0xac, 0xc6, 0x54, 0x75, 0x3d, 0xd8, 0x50, 0x09, 0x75, 0x5d, 0xa8, 0xf7, 0x4f, 0x43,
0x9a, 0xbe, 0xe8, 0x75, 0x37, 0x53, 0x46, 0xb1, 0x4e, 0xec, 0x8b, 0xaf, 0x86, 0x18, 0xb8, 0x89,
0xce, 0x24, 0xa1, 0x4e, 0x43, 0x97, 0x0b, 0x0a, 0x33, 0x0a, 0x24, 0xab, 0x31, 0xeb, 0x85, 0x9a,
0xce, 0x1f, 0xc2, 0x8b, 0x66, 0x8e, 0x17, 0xf1, 0xf2, 0x38, 0xeb, 0x45, 0xd3, 0xfa, 0x8b, 0x01,
0xd5, 0xe9, 0xa9, 0x83, 0x5c, 0xa8, 0xb1, 0xb8, 0x96, 0xb3, 0xcf, 0x60, 0xa7, 0xa1, 0xcf, 0xf9,
0xd5, 0x3c, 0x17, 0xe7, 0xb5, 0x80, 0xbd, 0xc5, 0xe6, 0x50, 0x1b, 0xf9, 0x56, 0x9a, 0xfa, 0x38,
0xfe, 0x0f, 0x56, 0x9a, 0xd6, 0xb7, 0x0d, 0x58, 0xd2, 0xd5, 0x87, 0x9a, 0xb0, 0x35, 0x24, 0xd1,
0x99, 0x4f, 0x9c, 0x4e, 0x84, 0x83, 0xee, 0x20, 0x79, 0x79, 0x1b, 0xf2, 0xc2, 0xda, 0x50, 0xcc,
0x96, 0xe4, 0xc5, 0xaf, 0xee, 0x3b, 0xb0, 0xae, 0x65, 0x78, 0x44, 0x88, 0x2e, 0x2b, 0x55, 0xa9,
0x15, 0xc5, 0x38, 0x8d, 0x08, 0x51, 0x85, 0x75, 0x13, 0xe2, 0xd2, 0x76, 0x92, 0xde, 0x2c, 0xdb,
0x25, 0x37, 0x6d, 0x1c, 0xcb, 0x87, 0xd5, 0x89, 0x89, 0x9a, 0xb3, 0x74, 0xcc, 0x59, 0x75, 0x0a,
0x73, 0x57, 0x9d, 0x89, 0x7b, 0x57, 0xd9, 0x4b, 0x09, 0xd6, 0xd7, 0x60, 0x39, 0x79, 0xf1, 0xd7,
0x61, 0x23, 0x76, 0x2e, 0x3b, 0xcf, 0xd4, 0x98, 0x5e, 0xd7, 0xac, 0xcc, 0x0a, 0x71, 0x13, 0xca,
0x6a, 0xfa, 0x4d, 0xac, 0x25, 0x25, 0x49, 0xd3, 0x43, 0xcf, 0x87, 0x72, 0xf6, 0x4f, 0x81, 0xc9,
0x1d, 0xc2, 0x78, 0xe1, 0x1d, 0xe2, 0x3a, 0xc0, 0x98, 0x72, 0xe2, 0x74, 0x33, 0xd3, 0x60, 0x45,
0x50, 0xee, 0x0b, 0x42, 0xab, 0xfc, 0xeb, 0x67, 0x37, 0x8c, 0xdf, 0x3c, 0xbb, 0x61, 0xfc, 0xf5,
0xd9, 0x0d, 0xa3, 0xb3, 0x28, 0xff, 0x19, 0x7e, 0xfd, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x4f,
0xdd, 0x49, 0x2f, 0x71, 0x16, 0x00, 0x00,
var fileDescriptor_types_0317e0784c4aa0b4 = []byte{
// 1938 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x58, 0x49, 0x8f, 0x23, 0x49,
0x15, 0x26, 0xed, 0x5a, 0x9f, 0xb3, 0xca, 0xae, 0xa8, 0xc5, 0x49, 0x6f, 0x55, 0x9d, 0x3d, 0xa3,
0xae, 0x6e, 0x66, 0x5c, 0xd8, 0x23, 0x68, 0x41, 0x33, 0x12, 0xe5, 0xae, 0x1a, 0xa6, 0xa0, 0x67,
0xa6, 0x95, 0x2e, 0xba, 0xe7, 0x00, 0x4a, 0x85, 0x9d, 0x61, 0x3b, 0xbb, 0xd2, 0x19, 0xa9, 0x8c,
0xb0, 0xa7, 0x0b, 0xf1, 0x07, 0x58, 0xc4, 0x8d, 0x03, 0x1c, 0x90, 0xe0, 0x5f, 0xb0, 0x9f, 0x90,
0x38, 0xb2, 0x09, 0x09, 0x09, 0x21, 0xd4, 0x67, 0xf6, 0x2b, 0x17, 0x94, 0x11, 0x91, 0x8b, 0xd3,
0xce, 0xaa, 0x6e, 0x86, 0x0b, 0x27, 0x2b, 0xdf, 0xfb, 0xde, 0x8b, 0xf7, 0x5e, 0xbc, 0x2d, 0x0c,
0xbb, 0x41, 0x48, 0x39, 0x3d, 0xe8, 0x12, 0xdc, 0xa3, 0xfe, 0x41, 0xd0, 0x0a, 0x0e, 0x26, 0xcd,
0x03, 0x7e, 0x1e, 0x10, 0xd6, 0x10, 0x1c, 0xb4, 0x43, 0xf8, 0x90, 0x84, 0x64, 0x3c, 0x6a, 0x48,
0x4c, 0x23, 0x68, 0x05, 0x8d, 0x49, 0xf3, 0xca, 0x55, 0x29, 0xd8, 0xa3, 0xa3, 0x11, 0xf5, 0x0f,
0x46, 0x84, 0x31, 0x3c, 0x88, 0x85, 0xcc, 0x7f, 0x57, 0xa0, 0xd2, 0x16, 0xf0, 0x0e, 0xc7, 0x9c,
0xa0, 0x47, 0x80, 0x26, 0xd8, 0x73, 0x1d, 0xcc, 0x69, 0x68, 0x87, 0x64, 0xe0, 0x32, 0x1e, 0x9e,
0x1b, 0xda, 0x5e, 0x79, 0xbf, 0xd2, 0xba, 0xd9, 0x98, 0x7f, 0x42, 0xe3, 0x71, 0x2c, 0x61, 0x6d,
0x24, 0xc2, 0x96, 0x92, 0x45, 0xc7, 0xb0, 0x3b, 0xab, 0xd1, 0x1e, 0x07, 0x0e, 0xe6, 0xc4, 0x26,
0x01, 0xed, 0x0d, 0x8d, 0xd2, 0x9e, 0xb6, 0xbf, 0x60, 0x5d, 0x9b, 0x91, 0xfd, 0xa2, 0x00, 0x1d,
0x47, 0x18, 0xf4, 0x7a, 0xd6, 0xb0, 0x2e, 0xf6, 0xb0, 0xdf, 0x23, 0xcc, 0x28, 0xef, 0x95, 0xf7,
0x17, 0x32, 0xa7, 0xb6, 0x15, 0x03, 0x1d, 0xc0, 0xa6, 0x87, 0x39, 0x61, 0xdc, 0x0e, 0xb1, 0xef,
0x60, 0x6a, 0x8f, 0xdc, 0x67, 0x84, 0x19, 0x7f, 0x59, 0xde, 0x2b, 0xef, 0xeb, 0xd6, 0x86, 0xe4,
0x59, 0x82, 0xf5, 0x4e, 0xc4, 0x41, 0x47, 0x70, 0x23, 0x08, 0xc9, 0xc4, 0xa5, 0x63, 0x66, 0xb3,
0xe1, 0xb8, 0xdf, 0xf7, 0x5c, 0x7f, 0x60, 0x33, 0x8e, 0x43, 0x6e, 0xb3, 0x21, 0x0e, 0x1d, 0xe3,
0xaf, 0xcb, 0xc2, 0xcc, 0xab, 0x31, 0xac, 0x13, 0xa3, 0x3a, 0x11, 0xa8, 0x13, 0x61, 0x50, 0x1b,
0xae, 0xf7, 0xc6, 0x61, 0x48, 0x7c, 0x5e, 0xa0, 0xe4, 0x6f, 0x52, 0xc9, 0x15, 0x85, 0x9a, 0xa7,
0xe3, 0x53, 0x60, 0xcc, 0xb1, 0x44, 0x46, 0xea, 0xef, 0x52, 0x7c, 0x67, 0xc6, 0x06, 0x19, 0xa4,
0x7b, 0x50, 0x9f, 0x3d, 0x5e, 0x4a, 0xfe, 0x43, 0x4a, 0x6e, 0xe7, 0x0f, 0x96, 0x82, 0x05, 0xde,
0x13, 0xe2, 0xd8, 0x43, 0xcc, 0x86, 0x6f, 0xb4, 0x8c, 0x7f, 0x46, 0xf2, 0xfa, 0x3c, 0xef, 0x09,
0x71, 0xde, 0x16, 0x98, 0x02, 0xef, 0x33, 0x4a, 0xfe, 0x25, 0x95, 0xcc, 0x7a, 0x9f, 0xea, 0xc8,
0x7a, 0xff, 0x74, 0xcc, 0xb8, 0xdb, 0x77, 0x89, 0xa3, 0x7c, 0xf8, 0x75, 0x75, 0xda, 0xfb, 0xcf,
0xc7, 0x7c, 0xe9, 0xc4, 0x3e, 0x54, 0xf3, 0x12, 0xbf, 0x91, 0x12, 0xeb, 0x4f, 0xa7, 0x91, 0x9f,
0x84, 0x1d, 0x45, 0xe9, 0x61, 0xee, 0x52, 0xdf, 0xee, 0xba, 0xbc, 0xef, 0x12, 0xcf, 0x31, 0x7e,
0x2b, 0x05, 0xb6, 0xa7, 0xd8, 0x6d, 0xc5, 0x8d, 0x4e, 0xe8, 0xbb, 0x3e, 0xf6, 0xdc, 0xaf, 0x24,
0x27, 0xfc, 0x4e, 0x9d, 0x90, 0xd0, 0xe5, 0x09, 0xef, 0x81, 0xca, 0x31, 0xbb, 0x17, 0x52, 0xc6,
0x3c, 0xd7, 0x3f, 0x63, 0xc6, 0x0f, 0xeb, 0x17, 0xd7, 0xd1, 0x83, 0x18, 0x6a, 0xd5, 0xa4, 0x70,
0x42, 0x60, 0xe8, 0xd3, 0xf0, 0x51, 0xa5, 0xb0, 0xeb, 0xd1, 0xde, 0x99, 0x1d, 0x52, 0xca, 0x55,
0x58, 0x99, 0xf1, 0xe3, 0xba, 0x48, 0xeb, 0x1d, 0x89, 0x68, 0x47, 0x00, 0x8b, 0x52, 0x2e, 0x43,
0xca, 0xd0, 0x67, 0xe0, 0x4a, 0x17, 0xf3, 0xde, 0x90, 0x38, 0xf3, 0x84, 0x7f, 0x22, 0x85, 0xeb,
0x0a, 0x32, 0x23, 0x7d, 0x0f, 0xea, 0xea, 0x64, 0xe6, 0x61, 0x26, 0x94, 0xc4, 0xe5, 0xf7, 0xd3,
0xba, 0xa8, 0xbf, 0x6d, 0xc9, 0xef, 0x48, 0x76, 0x52, 0x83, 0x5f, 0x4a, 0x6a, 0x10, 0xf3, 0xe8,
0x47, 0xc4, 0x92, 0x19, 0x3f, 0x93, 0x51, 0xb8, 0x5b, 0x14, 0x85, 0x47, 0xc4, 0x77, 0x5c, 0x7f,
0x70, 0x98, 0xca, 0x58, 0x48, 0xea, 0xc9, 0x90, 0xb2, 0x01, 0x71, 0x7d, 0x87, 0x3c, 0x9b, 0xf6,
0xe9, 0xe7, 0x53, 0x01, 0x39, 0x89, 0x00, 0x59, 0x97, 0xbe, 0x00, 0x2a, 0xc0, 0x36, 0xe1, 0xc3,
0xa6, 0xed, 0x60, 0x8e, 0x8d, 0xef, 0xef, 0xee, 0x69, 0xfb, 0x95, 0xd6, 0x5e, 0x91, 0x59, 0xc7,
0x7c, 0xd8, 0x3c, 0xc2, 0x1c, 0x5b, 0xeb, 0x52, 0x34, 0xfe, 0x46, 0xef, 0x40, 0x35, 0xd1, 0x62,
0x4f, 0x28, 0x27, 0xcc, 0xf8, 0xc1, 0xae, 0x70, 0xf1, 0x95, 0xcb, 0x74, 0x3d, 0xa6, 0x9c, 0x58,
0x6b, 0x24, 0xf3, 0xc5, 0x90, 0x09, 0xfa, 0x80, 0xf8, 0x84, 0xb9, 0xcc, 0xe6, 0xee, 0x88, 0x18,
0x5f, 0xbb, 0x2d, 0x12, 0xac, 0xa2, 0x88, 0xa7, 0xee, 0x88, 0xa0, 0x26, 0x2c, 0xf4, 0x69, 0x78,
0x66, 0x7c, 0xfd, 0xb6, 0xb0, 0xf9, 0x5a, 0xd1, 0x39, 0x6f, 0xd1, 0xf0, 0xcc, 0x12, 0x50, 0xb4,
0x09, 0x0b, 0xcc, 0xa3, 0xdc, 0xf8, 0x86, 0x54, 0x27, 0x3e, 0xcc, 0x00, 0x16, 0x22, 0x08, 0xba,
0x03, 0xb5, 0xa4, 0xe8, 0x26, 0x24, 0x64, 0x2e, 0xf5, 0x0d, 0x4d, 0xe0, 0xaa, 0x31, 0xfd, 0xb1,
0x24, 0xa3, 0xdb, 0x50, 0x8d, 0x6b, 0x3c, 0x46, 0xca, 0xf6, 0xbd, 0xae, 0xc8, 0x31, 0x70, 0x0b,
0x16, 0x65, 0x85, 0x94, 0x05, 0x5b, 0x7e, 0x98, 0xbf, 0xd7, 0x00, 0xcd, 0x5e, 0x30, 0xba, 0x0f,
0x0b, 0xe2, 0x12, 0x34, 0xe1, 0xcf, 0xed, 0x22, 0x7f, 0x32, 0x22, 0xe2, 0x2a, 0x84, 0x10, 0x6a,
0xc2, 0x16, 0x1e, 0x0c, 0x42, 0x32, 0xc8, 0xd5, 0x72, 0x49, 0x34, 0x9b, 0xcd, 0x0c, 0x2f, 0x29,
0xe4, 0x3b, 0x50, 0xeb, 0x8d, 0x19, 0xa7, 0xce, 0x79, 0x0a, 0x2f, 0x0b, 0x78, 0x55, 0xd1, 0x13,
0xe8, 0xab, 0xb0, 0xee, 0xfa, 0x3d, 0x6f, 0x1c, 0x39, 0x65, 0x8b, 0x10, 0x2e, 0x08, 0x87, 0xd6,
0x12, 0x6a, 0x27, 0x0a, 0xe5, 0x1f, 0x34, 0xa8, 0xfc, 0x9f, 0x78, 0x74, 0x00, 0x89, 0x06, 0x62,
0x33, 0x77, 0xe0, 0x63, 0x3e, 0x0e, 0x89, 0x70, 0x4b, 0xb7, 0x50, 0xc2, 0xea, 0xc4, 0x1c, 0xf3,
0x7b, 0x65, 0xa8, 0xe6, 0x0c, 0x45, 0x48, 0xe5, 0x93, 0x96, 0xa6, 0x53, 0x74, 0xe5, 0x72, 0xca,
0xc9, 0x8c, 0x90, 0x1f, 0xe8, 0x1e, 0x18, 0xd2, 0xe7, 0xd9, 0xe6, 0xa3, 0x2c, 0xdc, 0x96, 0xfc,
0x5c, 0xe7, 0x41, 0xf7, 0xe1, 0x8a, 0x48, 0x1a, 0xbb, 0x4b, 0xc7, 0xbe, 0x83, 0xc3, 0xf3, 0x29,
0x51, 0x69, 0x6e, 0x5d, 0x20, 0xda, 0x0a, 0x90, 0x11, 0xfe, 0x04, 0xd4, 0xc5, 0xf1, 0x73, 0x0e,
0x5d, 0x14, 0x92, 0x5b, 0x82, 0x9d, 0x3f, 0xf3, 0x61, 0xd2, 0x19, 0x92, 0xbe, 0x6d, 0x2c, 0x89,
0x2b, 0x7c, 0x81, 0xae, 0x5d, 0xcd, 0x75, 0xed, 0xa8, 0x58, 0xf2, 0x13, 0x69, 0x79, 0xee, 0x40,
0x7a, 0x13, 0xae, 0xa6, 0xc0, 0x59, 0x8b, 0x57, 0x84, 0xc5, 0x46, 0x02, 0xc9, 0x59, 0x6d, 0x7e,
0x15, 0xae, 0xe5, 0xee, 0xe7, 0xd0, 0x77, 0x1e, 0x24, 0xd7, 0xfe, 0xe1, 0x92, 0x71, 0x17, 0x2a,
0x99, 0xcc, 0x12, 0x77, 0xbb, 0x62, 0x41, 0x9a, 0x54, 0xe6, 0xb7, 0xcb, 0xb0, 0x9a, 0xac, 0x80,
0x68, 0x07, 0x96, 0x82, 0x71, 0xf7, 0x8c, 0x9c, 0x8b, 0xd3, 0x74, 0x4b, 0x7d, 0x45, 0xcb, 0xc1,
0x07, 0x2e, 0x1f, 0x3a, 0x21, 0xfe, 0x00, 0x7b, 0x76, 0x2f, 0x24, 0x0e, 0xf1, 0xb9, 0x8b, 0x3d,
0x16, 0x3b, 0x29, 0x93, 0xfb, 0x6a, 0x0a, 0x7a, 0x90, 0x62, 0xd4, 0xed, 0xdc, 0x81, 0x1a, 0xee,
0x71, 0x77, 0x22, 0xcb, 0x42, 0x06, 0x74, 0x51, 0xf6, 0xa9, 0x94, 0x2e, 0x23, 0x7a, 0x1d, 0x80,
0x3c, 0x73, 0xb9, 0x02, 0x2d, 0x09, 0xd0, 0x6a, 0x44, 0x91, 0xec, 0x3b, 0x50, 0xcb, 0x58, 0x93,
0xbd, 0x9a, 0x6a, 0x4a, 0x97, 0xd0, 0x5b, 0xb0, 0x16, 0x0f, 0x3e, 0x89, 0x5b, 0x11, 0x38, 0x5d,
0x11, 0x25, 0xe8, 0x11, 0xe8, 0x51, 0xe4, 0xc6, 0xcc, 0xee, 0x7b, 0x78, 0xc0, 0x0c, 0xd8, 0xd3,
0xf6, 0xd7, 0x5b, 0xaf, 0x5f, 0xba, 0x31, 0x37, 0x3a, 0x42, 0xea, 0xad, 0x48, 0xc8, 0xaa, 0xb0,
0xf4, 0xc3, 0xfc, 0x2c, 0x54, 0x32, 0x3c, 0x54, 0x81, 0xe5, 0x93, 0x77, 0x4f, 0x4e, 0x4f, 0x0e,
0x1f, 0xd6, 0x3e, 0x82, 0x10, 0xac, 0xcb, 0x8f, 0xd3, 0xe3, 0x23, 0xfb, 0xf8, 0xfd, 0x93, 0xd3,
0x9a, 0x86, 0x6a, 0xa0, 0x3f, 0x39, 0x39, 0x7d, 0xfb, 0xc8, 0x3a, 0x7c, 0x72, 0xd8, 0x7e, 0x78,
0x5c, 0x2b, 0x99, 0x1e, 0xd4, 0xc5, 0x46, 0x69, 0x11, 0xcc, 0xa2, 0x32, 0x1f, 0x11, 0x9f, 0x5b,
0xa4, 0x47, 0x43, 0x27, 0x4a, 0xcc, 0x74, 0x9b, 0x16, 0xf3, 0x53, 0x15, 0xf2, 0x7a, 0x42, 0x16,
0x43, 0xb3, 0xa0, 0xa4, 0xe3, 0xe2, 0x2f, 0x67, 0x66, 0xc9, 0xfb, 0xb0, 0x9a, 0x26, 0x7e, 0xd2,
0xfc, 0xb5, 0x4c, 0xf3, 0xbf, 0xa8, 0x26, 0x4b, 0xc5, 0x35, 0x69, 0xfe, 0xa8, 0x14, 0xbf, 0x51,
0x04, 0x67, 0x6e, 0xeb, 0x79, 0x0d, 0x50, 0x80, 0xc5, 0x54, 0x9a, 0xd5, 0x5a, 0x93, 0x9c, 0x4c,
0x95, 0xdf, 0x85, 0x8d, 0x28, 0xd4, 0x64, 0x4e, 0x2f, 0xaa, 0x0a, 0x46, 0x06, 0x7b, 0x0b, 0xd6,
0xd4, 0x13, 0x22, 0x24, 0x13, 0x82, 0x3d, 0xd5, 0x78, 0x74, 0x49, 0xb4, 0x04, 0x0d, 0xbd, 0x09,
0xab, 0xe9, 0x26, 0xb1, 0xf8, 0x82, 0x8b, 0xc4, 0x4a, 0x3c, 0xf8, 0xd1, 0x35, 0x58, 0x4d, 0xfb,
0xf0, 0x92, 0xd0, 0x9f, 0x12, 0xa2, 0xea, 0xed, 0x52, 0xe7, 0x5c, 0xe4, 0xe7, 0x05, 0xd5, 0x9b,
0x09, 0x51, 0x9b, 0x3a, 0xe7, 0x96, 0x10, 0x32, 0xbf, 0x53, 0x86, 0x6a, 0x8e, 0x83, 0x3e, 0x07,
0xfa, 0xd4, 0x46, 0x26, 0x9f, 0x77, 0xb7, 0x5e, 0xa0, 0x2d, 0x58, 0x53, 0x82, 0xe8, 0x09, 0xa0,
0x20, 0xa4, 0x01, 0x65, 0x24, 0x94, 0xcb, 0xa1, 0xeb, 0x0f, 0x98, 0x51, 0x12, 0xea, 0xf6, 0x0b,
0xf7, 0x3b, 0x25, 0xd1, 0x51, 0x02, 0xd6, 0x46, 0x90, 0xa3, 0x08, 0xc5, 0xf2, 0xa0, 0x29, 0xc5,
0xe5, 0x8b, 0x15, 0x1f, 0x2a, 0x89, 0x54, 0x31, 0xce, 0x51, 0x18, 0xba, 0x0f, 0x2b, 0x0e, 0x09,
0x28, 0x73, 0x39, 0x33, 0x16, 0x84, 0xba, 0xdd, 0x22, 0x75, 0x47, 0x12, 0x67, 0x25, 0x02, 0xe8,
0x5d, 0xa8, 0x4e, 0xa8, 0x37, 0xf6, 0x79, 0x34, 0x8b, 0xa2, 0x5e, 0xc2, 0x8c, 0x45, 0xa1, 0xe3,
0xd5, 0xc2, 0x3a, 0x8f, 0xe1, 0xc7, 0xcf, 0x5c, 0x6e, 0xad, 0x4f, 0xb2, 0x9f, 0xcc, 0xfc, 0xae,
0x06, 0xba, 0x3a, 0xe5, 0xc4, 0x0f, 0xc6, 0xbc, 0xb0, 0x77, 0x36, 0x60, 0x33, 0x08, 0x29, 0xed,
0xdb, 0xb4, 0x6f, 0x07, 0x94, 0x31, 0xc2, 0x92, 0xc5, 0x4b, 0x17, 0xe1, 0xa3, 0xfd, 0xf7, 0xfa,
0x8f, 0x12, 0xc6, 0xe5, 0xbd, 0xb6, 0x7c, 0x69, 0xaf, 0x35, 0x9f, 0x02, 0x92, 0x37, 0x85, 0xbd,
0x68, 0x13, 0x20, 0xce, 0x4b, 0x8e, 0xfd, 0xbb, 0xb0, 0x51, 0x34, 0xef, 0xab, 0xdd, 0x5c, 0x85,
0xff, 0x51, 0x83, 0x2d, 0x71, 0x47, 0xb8, 0xeb, 0x91, 0xec, 0x16, 0xf5, 0x31, 0xd8, 0x98, 0xea,
0x53, 0x6e, 0xf4, 0xea, 0xd0, 0xc4, 0xa3, 0xa3, 0x96, 0xed, 0x54, 0x11, 0x7d, 0xee, 0x0a, 0x54,
0x9a, 0xbf, 0x02, 0xc5, 0x03, 0xb1, 0xfc, 0xdf, 0x0c, 0xc4, 0x97, 0xde, 0x9f, 0xbe, 0xa5, 0x41,
0x45, 0xdd, 0xb3, 0x08, 0xe2, 0x09, 0xac, 0xa9, 0x9c, 0xb2, 0xdd, 0xe8, 0xde, 0xd5, 0x5c, 0x7e,
0xe5, 0x92, 0x4c, 0x14, 0x39, 0x62, 0xe9, 0x4e, 0x2e, 0x63, 0xf0, 0x88, 0x8e, 0x7d, 0xae, 0x82,
0xaf, 0xbe, 0xa2, 0x8e, 0x12, 0xbd, 0x1e, 0x18, 0xc7, 0xa3, 0x40, 0xb5, 0xe9, 0x94, 0x60, 0xfe,
0xa2, 0x04, 0xb5, 0x7c, 0x19, 0x46, 0x8b, 0x6e, 0x52, 0xcc, 0xd9, 0x91, 0xb0, 0x16, 0x53, 0xe5,
0x44, 0xb0, 0xa0, 0x1a, 0xa8, 0xbc, 0x90, 0x4f, 0x9e, 0xa6, 0x38, 0xfa, 0xa2, 0x07, 0xdd, 0x4c,
0x1a, 0xc5, 0x3a, 0xb1, 0x17, 0x7d, 0x35, 0xd1, 0xc7, 0x61, 0x2b, 0xd1, 0x99, 0x04, 0xd4, 0x6e,
0xaa, 0x74, 0x41, 0x41, 0x46, 0x81, 0x60, 0x35, 0x67, 0xad, 0x90, 0x0b, 0xe1, 0x87, 0xb0, 0xa2,
0x55, 0x60, 0x45, 0xbc, 0x2f, 0xce, 0x5a, 0xd1, 0x32, 0xff, 0xa4, 0x41, 0x2d, 0xdf, 0x75, 0x90,
0x03, 0x75, 0x16, 0xe7, 0x72, 0xf6, 0xe5, 0x6b, 0x37, 0xd5, 0x3d, 0xbf, 0x56, 0x64, 0xe2, 0xbc,
0x12, 0xb0, 0xb6, 0xd9, 0x1c, 0x6a, 0xb3, 0xf8, 0x94, 0x96, 0xba, 0x8e, 0xff, 0xc1, 0x29, 0x2d,
0xf3, 0x9b, 0x1a, 0x2c, 0xab, 0xec, 0x43, 0x2d, 0xd8, 0x1e, 0x91, 0xf0, 0xcc, 0x23, 0x76, 0x37,
0xc4, 0x7e, 0x6f, 0x98, 0x3c, 0xb6, 0x35, 0xf1, 0xd6, 0xde, 0x94, 0xcc, 0xb6, 0xe0, 0xc5, 0x0f,
0xed, 0xbb, 0xb0, 0xa1, 0x64, 0x78, 0x48, 0x88, 0x4a, 0x2b, 0x99, 0xa9, 0x55, 0xc9, 0x38, 0x0d,
0x09, 0x91, 0x89, 0x75, 0x13, 0xe2, 0xd4, 0xb6, 0x93, 0xda, 0xd4, 0xad, 0x8a, 0x93, 0x16, 0x8e,
0xe9, 0xc1, 0xda, 0x54, 0x47, 0x2d, 0xd8, 0x33, 0xe6, 0x6c, 0x37, 0xa5, 0xb9, 0xdb, 0xcd, 0xd4,
0xdc, 0x2d, 0xe7, 0xe6, 0xae, 0xf9, 0x65, 0x58, 0x49, 0x1e, 0xf9, 0x0d, 0xd8, 0x8c, 0x8d, 0xcb,
0xf6, 0x33, 0xd9, 0xa6, 0x37, 0x14, 0x2b, 0xb3, 0x35, 0xdc, 0x04, 0x5d, 0x76, 0xbf, 0xa9, 0x4d,
0xa4, 0x22, 0x68, 0xaa, 0xe9, 0x79, 0xa0, 0x67, 0xff, 0x07, 0x98, 0xde, 0x21, 0xb4, 0x97, 0xde,
0x21, 0xae, 0x03, 0x4c, 0x28, 0x27, 0x76, 0x2f, 0xd3, 0x0d, 0x56, 0x23, 0xca, 0x83, 0x88, 0xd0,
0xd6, 0x7f, 0xf9, 0xfc, 0x86, 0xf6, 0xab, 0xe7, 0x37, 0xb4, 0x3f, 0x3f, 0xbf, 0xa1, 0x75, 0x97,
0xc4, 0xbf, 0xbf, 0x6f, 0xfc, 0x27, 0x00, 0x00, 0xff, 0xff, 0x8d, 0xb3, 0x99, 0x07, 0x55, 0x16,
0x00, 0x00,
}

6
proto/beacon/p2p/v1/types.proto
View File

@@ -11,7 +11,7 @@ message BeaconState {
repeated uint64 validator_balances = 3; // Balance in Gwei
// Randomness and committees [1001-2000]
repeated bytes latest_randao_mixes_hash32s = 1004;
repeated bytes latest_randao_mixes = 1004;
uint64 previous_shuffling_start_shard = 1005;
uint64 current_shuffling_start_shard = 1006;
uint64 previous_shuffling_epoch = 1007;
@@ -112,9 +112,9 @@ message BeaconBlock {
uint64 slot = 1;
bytes parent_root_hash32 = 2;
bytes state_root_hash32 = 3;
bytes randao_reveal_hash32 = 4;
bytes randao_reveal = 4;
Eth1Data eth1_data = 5;
repeated bytes signature = 6; // bytes96
bytes signature = 6; // bytes96
// Block Body
BeaconBlockBody body = 7;

234
proto/beacon/rpc/v1/services.pb.go generated
View File

@@ -53,7 +53,7 @@ func (x ValidatorRole) String() string {
return proto.EnumName(ValidatorRole_name, int32(x))
}
func (ValidatorRole) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_services_646990b9daed6402, []int{0}
return fileDescriptor_services_03373b91a95c9201, []int{0}
}
type CommitteeRequest struct {
@@ -68,7 +68,7 @@ func (m *CommitteeRequest) Reset() { *m = CommitteeRequest{} }
func (m *CommitteeRequest) String() string { return proto.CompactTextString(m) }
func (*CommitteeRequest) ProtoMessage() {}
func (*CommitteeRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_services_646990b9daed6402, []int{0}
return fileDescriptor_services_03373b91a95c9201, []int{0}
}
func (m *CommitteeRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -123,7 +123,7 @@ func (m *CommitteeResponse) Reset() { *m = CommitteeResponse{} }
func (m *CommitteeResponse) String() string { return proto.CompactTextString(m) }
func (*CommitteeResponse) ProtoMessage() {}
func (*CommitteeResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_services_646990b9daed6402, []int{1}
return fileDescriptor_services_03373b91a95c9201, []int{1}
}
func (m *CommitteeResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -177,7 +177,7 @@ func (m *AttestationInfoRequest) Reset() { *m = AttestationInfoRequest{}
func (m *AttestationInfoRequest) String() string { return proto.CompactTextString(m) }
func (*AttestationInfoRequest) ProtoMessage() {}
func (*AttestationInfoRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_services_646990b9daed6402, []int{2}
return fileDescriptor_services_03373b91a95c9201, []int{2}
}
func (m *AttestationInfoRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -228,7 +228,7 @@ func (m *AttestationInfoResponse) Reset() { *m = AttestationInfoResponse
func (m *AttestationInfoResponse) String() string { return proto.CompactTextString(m) }
func (*AttestationInfoResponse) ProtoMessage() {}
func (*AttestationInfoResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_services_646990b9daed6402, []int{3}
return fileDescriptor_services_03373b91a95c9201, []int{3}
}
func (m *AttestationInfoResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -303,7 +303,7 @@ func (m *PendingAttestationsResponse) Reset() { *m = PendingAttestations
func (m *PendingAttestationsResponse) String() string { return proto.CompactTextString(m) }
func (*PendingAttestationsResponse) ProtoMessage() {}
func (*PendingAttestationsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_services_646990b9daed6402, []int{4}
return fileDescriptor_services_03373b91a95c9201, []int{4}
}
func (m *PendingAttestationsResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -350,7 +350,7 @@ func (m *CrosslinkCommitteeRequest) Reset() { *m = CrosslinkCommitteeReq
func (m *CrosslinkCommitteeRequest) String() string { return proto.CompactTextString(m) }
func (*CrosslinkCommitteeRequest) ProtoMessage() {}
func (*CrosslinkCommitteeRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_services_646990b9daed6402, []int{5}
return fileDescriptor_services_03373b91a95c9201, []int{5}
}
func (m *CrosslinkCommitteeRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -398,7 +398,7 @@ func (m *CrosslinkCommitteeResponse) Reset() { *m = CrosslinkCommitteeRe
func (m *CrosslinkCommitteeResponse) String() string { return proto.CompactTextString(m) }
func (*CrosslinkCommitteeResponse) ProtoMessage() {}
func (*CrosslinkCommitteeResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_services_646990b9daed6402, []int{6}
return fileDescriptor_services_03373b91a95c9201, []int{6}
}
func (m *CrosslinkCommitteeResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -453,7 +453,7 @@ func (m *ChainStartResponse) Reset() { *m = ChainStartResponse{} }
func (m *ChainStartResponse) String() string { return proto.CompactTextString(m) }
func (*ChainStartResponse) ProtoMessage() {}
func (*ChainStartResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_services_646990b9daed6402, []int{7}
return fileDescriptor_services_03373b91a95c9201, []int{7}
}
func (m *ChainStartResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -499,7 +499,7 @@ func (m *ChainStartResponse) GetGenesisTime() uint64 {
type ProposeRequest struct {
ParentHash []byte `protobuf:"bytes,1,opt,name=parent_hash,json=parentHash,proto3" json:"parent_hash,omitempty"`
SlotNumber uint64 `protobuf:"varint,2,opt,name=slot_number,json=slotNumber,proto3" json:"slot_number,omitempty"`
RandaoRevealHash32 []byte `protobuf:"bytes,3,opt,name=randao_reveal_hash32,json=randaoRevealHash32,proto3" json:"randao_reveal_hash32,omitempty"`
RandaoReveal []byte `protobuf:"bytes,3,opt,name=randao_reveal,json=randaoReveal,proto3" json:"randao_reveal,omitempty"`
AttestationBitmask []byte `protobuf:"bytes,4,opt,name=attestation_bitmask,json=attestationBitmask,proto3" json:"attestation_bitmask,omitempty"`
AttestationAggregateSig []uint64 `protobuf:"varint,5,rep,packed,name=attestation_aggregate_sig,json=attestationAggregateSig,proto3" json:"attestation_aggregate_sig,omitempty"`
Timestamp *types.Timestamp `protobuf:"bytes,6,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
@@ -512,7 +512,7 @@ func (m *ProposeRequest) Reset() { *m = ProposeRequest{} }
func (m *ProposeRequest) String() string { return proto.CompactTextString(m) }
func (*ProposeRequest) ProtoMessage() {}
func (*ProposeRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_services_646990b9daed6402, []int{8}
return fileDescriptor_services_03373b91a95c9201, []int{8}
}
func (m *ProposeRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -555,9 +555,9 @@ func (m *ProposeRequest) GetSlotNumber() uint64 {
return 0
}
func (m *ProposeRequest) GetRandaoRevealHash32() []byte {
func (m *ProposeRequest) GetRandaoReveal() []byte {
if m != nil {
return m.RandaoRevealHash32
return m.RandaoReveal
}
return nil
}
@@ -594,7 +594,7 @@ func (m *ProposeResponse) Reset() { *m = ProposeResponse{} }
func (m *ProposeResponse) String() string { return proto.CompactTextString(m) }
func (*ProposeResponse) ProtoMessage() {}
func (*ProposeResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_services_646990b9daed6402, []int{9}
return fileDescriptor_services_03373b91a95c9201, []int{9}
}
func (m *ProposeResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -641,7 +641,7 @@ func (m *ProposerIndexRequest) Reset() { *m = ProposerIndexRequest{} }
func (m *ProposerIndexRequest) String() string { return proto.CompactTextString(m) }
func (*ProposerIndexRequest) ProtoMessage() {}
func (*ProposerIndexRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_services_646990b9daed6402, []int{10}
return fileDescriptor_services_03373b91a95c9201, []int{10}
}
func (m *ProposerIndexRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -688,7 +688,7 @@ func (m *ProposerIndexResponse) Reset() { *m = ProposerIndexResponse{} }
func (m *ProposerIndexResponse) String() string { return proto.CompactTextString(m) }
func (*ProposerIndexResponse) ProtoMessage() {}
func (*ProposerIndexResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_services_646990b9daed6402, []int{11}
return fileDescriptor_services_03373b91a95c9201, []int{11}
}
func (m *ProposerIndexResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -735,7 +735,7 @@ func (m *StateRootResponse) Reset() { *m = StateRootResponse{} }
func (m *StateRootResponse) String() string { return proto.CompactTextString(m) }
func (*StateRootResponse) ProtoMessage() {}
func (*StateRootResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_services_646990b9daed6402, []int{12}
return fileDescriptor_services_03373b91a95c9201, []int{12}
}
func (m *StateRootResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -782,7 +782,7 @@ func (m *AttestResponse) Reset() { *m = AttestResponse{} }
func (m *AttestResponse) String() string { return proto.CompactTextString(m) }
func (*AttestResponse) ProtoMessage() {}
func (*AttestResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_services_646990b9daed6402, []int{13}
return fileDescriptor_services_03373b91a95c9201, []int{13}
}
func (m *AttestResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -832,7 +832,7 @@ func (m *Assignment) Reset() { *m = Assignment{} }
func (m *Assignment) String() string { return proto.CompactTextString(m) }
func (*Assignment) ProtoMessage() {}
func (*Assignment) Descriptor() ([]byte, []int) {
return fileDescriptor_services_646990b9daed6402, []int{14}
return fileDescriptor_services_03373b91a95c9201, []int{14}
}
func (m *Assignment) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -900,7 +900,7 @@ func (m *ValidatorIndexRequest) Reset() { *m = ValidatorIndexRequest{} }
func (m *ValidatorIndexRequest) String() string { return proto.CompactTextString(m) }
func (*ValidatorIndexRequest) ProtoMessage() {}
func (*ValidatorIndexRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_services_646990b9daed6402, []int{15}
return fileDescriptor_services_03373b91a95c9201, []int{15}
}
func (m *ValidatorIndexRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -947,7 +947,7 @@ func (m *ValidatorIndexResponse) Reset() { *m = ValidatorIndexResponse{}
func (m *ValidatorIndexResponse) String() string { return proto.CompactTextString(m) }
func (*ValidatorIndexResponse) ProtoMessage() {}
func (*ValidatorIndexResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_services_646990b9daed6402, []int{16}
return fileDescriptor_services_03373b91a95c9201, []int{16}
}
func (m *ValidatorIndexResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -995,7 +995,7 @@ func (m *ValidatorEpochAssignmentsRequest) Reset() { *m = ValidatorEpoch
func (m *ValidatorEpochAssignmentsRequest) String() string { return proto.CompactTextString(m) }
func (*ValidatorEpochAssignmentsRequest) ProtoMessage() {}
func (*ValidatorEpochAssignmentsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_services_646990b9daed6402, []int{17}
return fileDescriptor_services_03373b91a95c9201, []int{17}
}
func (m *ValidatorEpochAssignmentsRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -1049,7 +1049,7 @@ func (m *ValidatorEpochAssignmentsResponse) Reset() { *m = ValidatorEpoc
func (m *ValidatorEpochAssignmentsResponse) String() string { return proto.CompactTextString(m) }
func (*ValidatorEpochAssignmentsResponse) ProtoMessage() {}
func (*ValidatorEpochAssignmentsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_services_646990b9daed6402, []int{18}
return fileDescriptor_services_03373b91a95c9201, []int{18}
}
func (m *ValidatorEpochAssignmentsResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -1096,7 +1096,7 @@ func (m *PendingDepositsResponse) Reset() { *m = PendingDepositsResponse
func (m *PendingDepositsResponse) String() string { return proto.CompactTextString(m) }
func (*PendingDepositsResponse) ProtoMessage() {}
func (*PendingDepositsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_services_646990b9daed6402, []int{19}
return fileDescriptor_services_03373b91a95c9201, []int{19}
}
func (m *PendingDepositsResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -1143,7 +1143,7 @@ func (m *Eth1DataResponse) Reset() { *m = Eth1DataResponse{} }
func (m *Eth1DataResponse) String() string { return proto.CompactTextString(m) }
func (*Eth1DataResponse) ProtoMessage() {}
func (*Eth1DataResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_services_646990b9daed6402, []int{20}
return fileDescriptor_services_03373b91a95c9201, []int{20}
}
func (m *Eth1DataResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -2171,11 +2171,11 @@ func (m *ProposeRequest) MarshalTo(dAtA []byte) (int, error) {
i++
i = encodeVarintServices(dAtA, i, uint64(m.SlotNumber))
}
if len(m.RandaoRevealHash32) > 0 {
if len(m.RandaoReveal) > 0 {
dAtA[i] = 0x1a
i++
i = encodeVarintServices(dAtA, i, uint64(len(m.RandaoRevealHash32)))
i += copy(dAtA[i:], m.RandaoRevealHash32)
i = encodeVarintServices(dAtA, i, uint64(len(m.RandaoReveal)))
i += copy(dAtA[i:], m.RandaoReveal)
}
if len(m.AttestationBitmask) > 0 {
dAtA[i] = 0x22
@@ -2752,7 +2752,7 @@ func (m *ProposeRequest) Size() (n int) {
if m.SlotNumber != 0 {
n += 1 + sovServices(uint64(m.SlotNumber))
}
l = len(m.RandaoRevealHash32)
l = len(m.RandaoReveal)
if l > 0 {
n += 1 + l + sovServices(uint64(l))
}
@@ -3957,7 +3957,7 @@ func (m *ProposeRequest) Unmarshal(dAtA []byte) error {
}
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field RandaoRevealHash32", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field RandaoReveal", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
@@ -3981,9 +3981,9 @@ func (m *ProposeRequest) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.RandaoRevealHash32 = append(m.RandaoRevealHash32[:0], dAtA[iNdEx:postIndex]...)
if m.RandaoRevealHash32 == nil {
m.RandaoRevealHash32 = []byte{}
m.RandaoReveal = append(m.RandaoReveal[:0], dAtA[iNdEx:postIndex]...)
if m.RandaoReveal == nil {
m.RandaoReveal = []byte{}
}
iNdEx = postIndex
case 4:
@@ -5279,90 +5279,90 @@ var (
)
func init() {
proto.RegisterFile("proto/beacon/rpc/v1/services.proto", fileDescriptor_services_646990b9daed6402)
proto.RegisterFile("proto/beacon/rpc/v1/services.proto", fileDescriptor_services_03373b91a95c9201)
}
var fileDescriptor_services_646990b9daed6402 = []byte{
// 1289 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x57, 0xcf, 0x6e, 0x1b, 0x45,
0x18, 0x67, 0xe3, 0xa4, 0x4d, 0x3e, 0x27, 0xb1, 0x33, 0x4d, 0x1a, 0xd7, 0x85, 0x26, 0xdd, 0x4a,
0x34, 0xad, 0xe8, 0x3a, 0xd9, 0x4a, 0xb4, 0x50, 0xf5, 0x60, 0xa7, 0x86, 0x96, 0x46, 0x49, 0xba,
0x36, 0xad, 0x40, 0x48, 0xab, 0xb1, 0x3d, 0xb5, 0x97, 0xd8, 0x3b, 0xcb, 0xce, 0xd8, 0x6a, 0x9e,
0x80, 0x03, 0x17, 0x5e, 0x82, 0x13, 0x77, 0xde, 0x00, 0x89, 0x23, 0x8f, 0x80, 0x7a, 0xe0, 0x39,
0xd0, 0xce, 0xcc, 0x8e, 0xd7, 0x6b, 0x6f, 0x62, 0xe0, 0xe6, 0xfd, 0xfe, 0xfc, 0xe6, 0xfb, 0x37,
0xbf, 0x6f, 0x0c, 0x66, 0x10, 0x52, 0x4e, 0x2b, 0x2d, 0x82, 0xdb, 0xd4, 0xaf, 0x84, 0x41, 0xbb,
0x32, 0x3a, 0xa8, 0x30, 0x12, 0x8e, 0xbc, 0x36, 0x61, 0x96, 0x50, 0xa2, 0xeb, 0x84, 0xf7, 0x48,
0x48, 0x86, 0x03, 0x4b, 0x9a, 0x59, 0x61, 0xd0, 0xb6, 0x46, 0x07, 0xe5, 0x9d, 0x09, 0xdf, 0xc0,
0x0e, 0x22, 0x5f, 0x7e, 0x1e, 0xc4, 0x8e, 0xe5, 0x9b, 0x5d, 0x4a, 0xbb, 0x7d, 0x52, 0x11, 0x5f,
0xad, 0xe1, 0xdb, 0x0a, 0x19, 0x04, 0xfc, 0x5c, 0x29, 0x77, 0xd2, 0x4a, 0xee, 0x0d, 0x08, 0xe3,
0x78, 0x10, 0x48, 0x03, 0xf3, 0x04, 0x8a, 0x87, 0x74, 0x30, 0xf0, 0x38, 0x27, 0xc4, 0x21, 0x3f,
0x0c, 0x09, 0xe3, 0x08, 0xc1, 0x22, 0xeb, 0x53, 0x5e, 0x32, 0x76, 0x8d, 0xbd, 0x45, 0x47, 0xfc,
0x46, 0x77, 0xa1, 0x30, 0xc2, 0x7d, 0xaf, 0x83, 0x39, 0x0d, 0x5d, 0xcf, 0xef, 0x90, 0x77, 0xa5,
0x05, 0xa1, 0x5e, 0xd7, 0xe2, 0x17, 0x91, 0xd4, 0xfc, 0x12, 0x36, 0x12, 0x80, 0x2c, 0xa0, 0x3e,
0x23, 0xe8, 0x43, 0x58, 0x69, 0xc7, 0xc2, 0x92, 0xb1, 0x9b, 0xdb, 0x5b, 0x74, 0xc6, 0x02, 0xb4,
0x09, 0x4b, 0xac, 0x87, 0xc3, 0x8e, 0x42, 0x94, 0x1f, 0xa6, 0x05, 0xd7, 0xab, 0x9c, 0x47, 0xc1,
0x72, 0x8f, 0xfa, 0x2f, 0xfc, 0xb7, 0x34, 0x8e, 0x4f, 0xdb, 0x1b, 0x49, 0xfb, 0xdf, 0x17, 0x60,
0x7b, 0xca, 0x41, 0x9d, 0xff, 0x08, 0x4a, 0xb2, 0x80, 0x6e, 0xab, 0x4f, 0xdb, 0x67, 0x6e, 0x48,
0x29, 0x77, 0x7b, 0x98, 0xf5, 0x1e, 0xda, 0x02, 0x64, 0xd5, 0xd9, 0x92, 0xfa, 0x5a, 0xa4, 0x76,
0x28, 0xe5, 0xcf, 0x85, 0x12, 0x3d, 0x81, 0x32, 0x09, 0x68, 0xbb, 0xe7, 0xb6, 0xe8, 0xd0, 0xef,
0xe0, 0xf0, 0x7c, 0xc2, 0x75, 0x41, 0xb8, 0x6e, 0x0b, 0x8b, 0x9a, 0x32, 0x48, 0x38, 0xdf, 0x85,
0xc2, 0xf7, 0x43, 0xc6, 0xbd, 0xb7, 0x1e, 0xe9, 0xb8, 0xc2, 0xa8, 0x94, 0x93, 0x35, 0xd3, 0xe2,
0x7a, 0x24, 0x45, 0x4f, 0xe1, 0xe6, 0xd8, 0x70, 0x3a, 0xc2, 0x45, 0x71, 0x4c, 0x49, 0x9b, 0xa4,
0x83, 0x3c, 0x82, 0x62, 0x1f, 0x47, 0x89, 0xbb, 0xed, 0x90, 0x32, 0xd6, 0xf7, 0xfc, 0xb3, 0xd2,
0xd2, 0xae, 0xb1, 0x97, 0xb7, 0x6f, 0x5b, 0xe9, 0xa9, 0x0a, 0xec, 0xc0, 0x1a, 0x1d, 0x58, 0x87,
0xb1, 0xa1, 0x53, 0x90, 0xae, 0x5a, 0x60, 0x0e, 0xe1, 0xe6, 0x29, 0xf1, 0x3b, 0x9e, 0xdf, 0x4d,
0x54, 0x93, 0xe9, 0x52, 0xbe, 0x86, 0xcd, 0x40, 0xaa, 0x5d, 0x9c, 0xd0, 0x8b, 0xae, 0xe6, 0xed,
0x3b, 0x59, 0x07, 0x26, 0xb0, 0x9c, 0x6b, 0xc1, 0x34, 0xbe, 0x59, 0x81, 0x1b, 0x3a, 0x86, 0x79,
0x26, 0xd2, 0x3c, 0x85, 0xf2, 0x2c, 0x87, 0xff, 0x31, 0x71, 0xaf, 0x00, 0x1d, 0xf6, 0xb0, 0xe7,
0x37, 0x38, 0x0e, 0xb9, 0x46, 0x2a, 0xc1, 0x55, 0x16, 0x09, 0x88, 0x9c, 0xb7, 0x65, 0x27, 0xfe,
0x44, 0xb7, 0x61, 0xb5, 0x4b, 0x7c, 0xc2, 0x3c, 0xe6, 0x46, 0xd7, 0x4a, 0x81, 0xe5, 0x95, 0xac,
0xe9, 0x0d, 0x88, 0xf9, 0xeb, 0x02, 0xac, 0x9f, 0x86, 0x34, 0xa0, 0x4c, 0xe7, 0xb2, 0x03, 0xf9,
0x00, 0x87, 0xc4, 0x97, 0xed, 0x55, 0xe3, 0x07, 0x52, 0x14, 0x35, 0x34, 0x32, 0x88, 0x12, 0x74,
0xfd, 0xe1, 0xa0, 0x45, 0x42, 0x85, 0x0a, 0x91, 0xe8, 0x58, 0x48, 0xd0, 0x3e, 0x6c, 0x86, 0xd8,
0xef, 0x60, 0xea, 0x86, 0x64, 0x44, 0x70, 0x3f, 0x9e, 0x93, 0x9c, 0x80, 0x42, 0x52, 0xe7, 0x08,
0x95, 0x9a, 0x90, 0x0a, 0x5c, 0x4b, 0x34, 0xcb, 0x6d, 0x79, 0x7c, 0x80, 0xd9, 0x99, 0x1a, 0x2c,
0x94, 0x50, 0xd5, 0xa4, 0x06, 0x7d, 0x0e, 0x37, 0x92, 0x0e, 0xb8, 0xdb, 0x0d, 0x49, 0x17, 0x73,
0xe2, 0x32, 0xaf, 0x5b, 0x5a, 0x12, 0xe5, 0xdc, 0x4e, 0x18, 0x54, 0x63, 0x7d, 0xc3, 0xeb, 0xa2,
0xc7, 0xb0, 0xa2, 0x59, 0xa6, 0x74, 0x45, 0xcc, 0x61, 0xd9, 0x92, 0x3c, 0x64, 0xc5, 0x3c, 0x64,
0x35, 0x63, 0x0b, 0x67, 0x6c, 0x6c, 0xee, 0x43, 0x41, 0x17, 0x4b, 0x55, 0xff, 0x23, 0x00, 0x79,
0x21, 0x12, 0xc5, 0x5a, 0x11, 0x92, 0x28, 0x35, 0xf3, 0x11, 0x6c, 0x2a, 0x0f, 0x49, 0x3f, 0x89,
0x22, 0x27, 0x6b, 0x68, 0xa4, 0x6b, 0x68, 0x3e, 0x80, 0xad, 0x94, 0xa3, 0x3a, 0x70, 0x13, 0x96,
0x24, 0xbd, 0x29, 0x72, 0x11, 0x1f, 0xa6, 0x0d, 0x1b, 0x0d, 0x8e, 0x39, 0x89, 0x6e, 0x5d, 0x32,
0xb6, 0x28, 0x7f, 0x22, 0x2e, 0x6b, 0x1c, 0x1b, 0x8b, 0xcd, 0xcc, 0x27, 0xb0, 0x2e, 0x27, 0x5c,
0x3b, 0xdc, 0x83, 0x62, 0xb2, 0xaa, 0x89, 0x94, 0x0a, 0x09, 0xb9, 0x48, 0xec, 0x27, 0x03, 0xa0,
0xca, 0x98, 0xd7, 0xf5, 0x07, 0xc4, 0xe7, 0xd1, 0x51, 0xc1, 0xb0, 0xd5, 0xf7, 0xda, 0xee, 0x19,
0x39, 0x8f, 0x8f, 0x92, 0x92, 0x97, 0xe4, 0x7c, 0xf6, 0x3c, 0xa3, 0x3b, 0xb0, 0x26, 0x61, 0x49,
0xe8, 0x8a, 0xeb, 0x23, 0xd9, 0x67, 0x35, 0x16, 0x36, 0x22, 0x62, 0xbf, 0x03, 0x6b, 0x81, 0x2a,
0x84, 0x34, 0x5a, 0x94, 0x46, 0xb1, 0x30, 0x32, 0x32, 0x3f, 0x85, 0xad, 0xd7, 0x13, 0x34, 0x1f,
0xd7, 0xf9, 0xe2, 0xb8, 0x22, 0x0e, 0x4f, 0xfb, 0x5d, 0x58, 0xe6, 0x16, 0xec, 0x6a, 0x7b, 0x41,
0x8d, 0xe3, 0x12, 0xb0, 0x44, 0x6b, 0x25, 0x25, 0x8b, 0x6b, 0x18, 0xb7, 0x56, 0x88, 0xc4, 0xc5,
0x4d, 0xc5, 0xb4, 0x90, 0x8e, 0xa9, 0x0b, 0xb7, 0x2f, 0x38, 0x43, 0x85, 0x57, 0x03, 0xc0, 0x5a,
0x2c, 0x30, 0xf2, 0xb6, 0x69, 0xcd, 0x5e, 0xd1, 0xd6, 0x18, 0xc0, 0x49, 0x78, 0x99, 0x04, 0xb6,
0x15, 0x91, 0x3e, 0x23, 0x01, 0x65, 0x5e, 0x02, 0xfe, 0x2b, 0x28, 0xc6, 0x24, 0xda, 0x51, 0x3a,
0x45, 0xa0, 0x3b, 0x59, 0x04, 0xaa, 0x30, 0x9c, 0x42, 0x30, 0x89, 0x69, 0xbe, 0x82, 0x62, 0x9d,
0xf7, 0x0e, 0x9e, 0x61, 0x8e, 0x35, 0xfe, 0x53, 0x58, 0x21, 0xbc, 0x77, 0xe0, 0x76, 0x30, 0xc7,
0xa2, 0x42, 0x79, 0x7b, 0x37, 0x0b, 0x58, 0x3b, 0x2f, 0x13, 0xf5, 0xeb, 0x7e, 0x0d, 0xd6, 0x74,
0x89, 0x1c, 0xda, 0x27, 0x28, 0x0f, 0x57, 0xbf, 0x3e, 0x7e, 0x79, 0x7c, 0xf2, 0xe6, 0xb8, 0xf8,
0x01, 0x5a, 0x85, 0xe5, 0x6a, 0xb3, 0x59, 0x6f, 0x34, 0xeb, 0x4e, 0xd1, 0x88, 0xbe, 0x4e, 0x9d,
0x93, 0xd3, 0x93, 0x46, 0xdd, 0x29, 0x2e, 0xa0, 0x65, 0x58, 0xac, 0x9d, 0x34, 0x9f, 0x17, 0x73,
0xf6, 0x6f, 0x39, 0x58, 0xab, 0x89, 0x83, 0x1a, 0xf2, 0xa1, 0x83, 0xbe, 0x81, 0x8d, 0x37, 0xd8,
0xe3, 0x5f, 0xd0, 0x70, 0xcc, 0xb2, 0xe8, 0xfa, 0x14, 0x33, 0xd4, 0xa3, 0xe7, 0x4b, 0xf9, 0x7e,
0x56, 0xb1, 0xa7, 0x19, 0x7a, 0xdf, 0x40, 0x47, 0xb0, 0x76, 0x88, 0x7d, 0xea, 0x7b, 0x6d, 0xdc,
0x7f, 0x4e, 0x70, 0x27, 0x13, 0x36, 0x73, 0x3f, 0xd5, 0xc6, 0xeb, 0x1f, 0x39, 0xb0, 0x71, 0x24,
0x96, 0x62, 0x62, 0x41, 0xfd, 0x7b, 0xc4, 0x84, 0xf3, 0xbe, 0x81, 0xbe, 0x85, 0x42, 0x6a, 0x18,
0x32, 0x11, 0x2b, 0x59, 0xa9, 0x67, 0x4d, 0xd3, 0x11, 0x2c, 0xc7, 0x4d, 0xcc, 0x04, 0xdd, 0xcb,
0x02, 0x4d, 0xcf, 0x8e, 0xfd, 0xb7, 0x01, 0x85, 0x6a, 0xcc, 0x10, 0xba, 0x75, 0x20, 0x45, 0xa2,
0xb8, 0xf3, 0xa4, 0x5c, 0xfe, 0x38, 0xf3, 0xb6, 0x4c, 0x72, 0xe2, 0x3b, 0xd8, 0x4a, 0xbd, 0xda,
0xaa, 0x5c, 0x10, 0x93, 0x75, 0x31, 0x40, 0xfa, 0x55, 0x98, 0x5d, 0xb6, 0x8c, 0x47, 0xa1, 0xfd,
0x4b, 0x4e, 0xaf, 0x1b, 0x9d, 0x68, 0x1f, 0xd6, 0x26, 0xd6, 0x02, 0xfa, 0x24, 0xb3, 0x19, 0x33,
0xd6, 0x4e, 0xf9, 0xc1, 0x9c, 0xd6, 0x2a, 0xf7, 0x16, 0x5c, 0x9b, 0xf1, 0xd4, 0xca, 0xec, 0xe1,
0xc3, 0x4b, 0x06, 0x63, 0xe6, 0x7b, 0xed, 0x3b, 0x58, 0x55, 0x87, 0xcb, 0xe1, 0x9e, 0xe7, 0x06,
0x94, 0xef, 0x5e, 0x92, 0x47, 0x22, 0x83, 0xe8, 0xef, 0x43, 0x30, 0xe4, 0x44, 0xaf, 0xc7, 0xf9,
0x4e, 0xb8, 0x97, 0x75, 0xc2, 0xd4, 0x9a, 0xb5, 0x7f, 0xcc, 0x41, 0x51, 0xd3, 0x51, 0xdc, 0x28,
0x0a, 0xeb, 0x93, 0x9b, 0x05, 0x65, 0xd6, 0x7e, 0xe6, 0xe6, 0x2a, 0x5b, 0xf3, 0x9a, 0xab, 0x4c,
0x7f, 0x36, 0xe0, 0x46, 0xe6, 0xde, 0x40, 0x8f, 0x2f, 0x45, 0xcb, 0x58, 0x67, 0xe5, 0xcf, 0xfe,
0x83, 0xa7, 0x0a, 0x89, 0x42, 0x49, 0x1b, 0xe9, 0x17, 0xb0, 0xba, 0x3d, 0x99, 0xf7, 0x3d, 0xfd,
0xb6, 0xce, 0xee, 0xc4, 0xd4, 0xa3, 0xba, 0xb6, 0xfa, 0xc7, 0xfb, 0x5b, 0xc6, 0x9f, 0xef, 0x6f,
0x19, 0x7f, 0xbd, 0xbf, 0x65, 0xb4, 0xae, 0x88, 0xf1, 0x7c, 0xf8, 0x4f, 0x00, 0x00, 0x00, 0xff,
0xff, 0xa2, 0xff, 0x62, 0xb4, 0xde, 0x0e, 0x00, 0x00,
var fileDescriptor_services_03373b91a95c9201 = []byte{
// 1287 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x57, 0xdd, 0x6e, 0x1b, 0x45,
0x14, 0x66, 0xf3, 0xd3, 0x26, 0xc7, 0x76, 0xec, 0x4c, 0x93, 0xc6, 0x75, 0xa1, 0x49, 0xb7, 0x12,
0x4d, 0x2b, 0xba, 0x6e, 0xb6, 0x12, 0x2d, 0x54, 0xbd, 0xb0, 0x53, 0x43, 0x4b, 0xa3, 0x24, 0x5d,
0x9b, 0x56, 0x20, 0xa4, 0xd5, 0xd8, 0x9e, 0xda, 0x4b, 0xec, 0x9d, 0x65, 0x67, 0x6c, 0x35, 0x4f,
0xc0, 0x05, 0x37, 0x3c, 0x01, 0x77, 0xbc, 0x02, 0x6f, 0x80, 0xc4, 0x25, 0x8f, 0x80, 0x7a, 0xc1,
0x73, 0xa0, 0x9d, 0x99, 0x1d, 0xaf, 0xd7, 0xde, 0xd4, 0xc0, 0x9d, 0xf7, 0xfc, 0xcd, 0x39, 0xdf,
0x39, 0xf3, 0x9d, 0x31, 0x98, 0x41, 0x48, 0x39, 0xad, 0xb6, 0x09, 0xee, 0x50, 0xbf, 0x1a, 0x06,
0x9d, 0xea, 0xf8, 0xa0, 0xca, 0x48, 0x38, 0xf6, 0x3a, 0x84, 0x59, 0x42, 0x89, 0xae, 0x12, 0xde,
0x27, 0x21, 0x19, 0x0d, 0x2d, 0x69, 0x66, 0x85, 0x41, 0xc7, 0x1a, 0x1f, 0x54, 0x76, 0xa7, 0x7c,
0x03, 0x3b, 0x88, 0x7c, 0xf9, 0x79, 0x10, 0x3b, 0x56, 0xae, 0xf7, 0x28, 0xed, 0x0d, 0x48, 0x55,
0x7c, 0xb5, 0x47, 0x6f, 0xaa, 0x64, 0x18, 0xf0, 0x73, 0xa5, 0xdc, 0x4d, 0x2b, 0xb9, 0x37, 0x24,
0x8c, 0xe3, 0x61, 0x20, 0x0d, 0xcc, 0x13, 0x28, 0x1d, 0xd2, 0xe1, 0xd0, 0xe3, 0x9c, 0x10, 0x87,
0xfc, 0x30, 0x22, 0x8c, 0x23, 0x04, 0x2b, 0x6c, 0x40, 0x79, 0xd9, 0xd8, 0x33, 0xf6, 0x57, 0x1c,
0xf1, 0x1b, 0xdd, 0x86, 0xe2, 0x18, 0x0f, 0xbc, 0x2e, 0xe6, 0x34, 0x74, 0x3d, 0xbf, 0x4b, 0xde,
0x96, 0x97, 0x84, 0x7a, 0x43, 0x8b, 0x9f, 0x47, 0x52, 0xf3, 0x4b, 0xd8, 0x4c, 0x04, 0x64, 0x01,
0xf5, 0x19, 0x41, 0x1f, 0xc2, 0x7a, 0x27, 0x16, 0x96, 0x8d, 0xbd, 0xe5, 0xfd, 0x15, 0x67, 0x22,
0x40, 0x5b, 0xb0, 0xca, 0xfa, 0x38, 0xec, 0xaa, 0x88, 0xf2, 0xc3, 0xb4, 0xe0, 0x6a, 0x8d, 0xf3,
0x28, 0x59, 0xee, 0x51, 0xff, 0xb9, 0xff, 0x86, 0xc6, 0xf9, 0x69, 0x7b, 0x23, 0x69, 0xff, 0xfb,
0x12, 0xec, 0xcc, 0x38, 0xa8, 0xf3, 0x1f, 0x42, 0x59, 0x02, 0xe8, 0xb6, 0x07, 0xb4, 0x73, 0xe6,
0x86, 0x94, 0x72, 0xb7, 0x8f, 0x59, 0xff, 0x81, 0x2d, 0x82, 0xe4, 0x9d, 0x6d, 0xa9, 0xaf, 0x47,
0x6a, 0x87, 0x52, 0xfe, 0x4c, 0x28, 0xd1, 0x63, 0xa8, 0x90, 0x80, 0x76, 0xfa, 0x6e, 0x9b, 0x8e,
0xfc, 0x2e, 0x0e, 0xcf, 0xa7, 0x5c, 0x97, 0x84, 0xeb, 0x8e, 0xb0, 0xa8, 0x2b, 0x83, 0x84, 0xf3,
0x6d, 0x28, 0x7e, 0x3f, 0x62, 0xdc, 0x7b, 0xe3, 0x91, 0xae, 0x2b, 0x8c, 0xca, 0xcb, 0x12, 0x33,
0x2d, 0x6e, 0x44, 0x52, 0xf4, 0x04, 0xae, 0x4f, 0x0c, 0x67, 0x33, 0x5c, 0x11, 0xc7, 0x94, 0xb5,
0x49, 0x3a, 0xc9, 0x23, 0x28, 0x0d, 0x70, 0x54, 0xb8, 0xdb, 0x09, 0x29, 0x63, 0x03, 0xcf, 0x3f,
0x2b, 0xaf, 0xee, 0x19, 0xfb, 0x39, 0xfb, 0xa6, 0x95, 0x9e, 0xaa, 0xc0, 0x0e, 0xac, 0xf1, 0x81,
0x75, 0x18, 0x1b, 0x3a, 0x45, 0xe9, 0xaa, 0x05, 0xe6, 0x08, 0xae, 0x9f, 0x12, 0xbf, 0xeb, 0xf9,
0xbd, 0x04, 0x9a, 0x4c, 0x43, 0xf9, 0x0a, 0xb6, 0x02, 0xa9, 0x76, 0x71, 0x42, 0x2f, 0xba, 0x9a,
0xb3, 0x6f, 0x65, 0x1d, 0x98, 0x88, 0xe5, 0x5c, 0x09, 0x66, 0xe3, 0x9b, 0x55, 0xb8, 0xa6, 0x73,
0x58, 0x64, 0x22, 0xcd, 0x53, 0xa8, 0xcc, 0x73, 0xf8, 0x1f, 0x13, 0xf7, 0x12, 0xd0, 0x61, 0x1f,
0x7b, 0x7e, 0x93, 0xe3, 0x90, 0xeb, 0x48, 0x65, 0xb8, 0xcc, 0x22, 0x01, 0x91, 0xf3, 0xb6, 0xe6,
0xc4, 0x9f, 0xe8, 0x26, 0xe4, 0x7b, 0xc4, 0x27, 0xcc, 0x63, 0x6e, 0x74, 0xad, 0x54, 0xb0, 0x9c,
0x92, 0xb5, 0xbc, 0x21, 0x31, 0x7f, 0x59, 0x82, 0x8d, 0xd3, 0x90, 0x06, 0x94, 0xe9, 0x5a, 0x76,
0x21, 0x17, 0xe0, 0x90, 0xf8, 0xb2, 0xbd, 0x6a, 0xfc, 0x40, 0x8a, 0xa2, 0x86, 0x46, 0x06, 0x51,
0x81, 0xae, 0x3f, 0x1a, 0xb6, 0x49, 0xa8, 0xa2, 0x42, 0x24, 0x3a, 0x16, 0x12, 0x74, 0x0b, 0x0a,
0x21, 0xf6, 0xbb, 0x98, 0xba, 0x21, 0x19, 0x13, 0x3c, 0x10, 0x53, 0x95, 0x77, 0xf2, 0x52, 0xe8,
0x08, 0x19, 0xaa, 0xc2, 0x95, 0x44, 0x7f, 0xdc, 0xb6, 0xc7, 0x87, 0x98, 0x9d, 0xa9, 0x59, 0x42,
0x09, 0x55, 0x5d, 0x6a, 0xd0, 0xe7, 0x70, 0x2d, 0xe9, 0x80, 0x7b, 0xbd, 0x90, 0xf4, 0x30, 0x27,
0x2e, 0xf3, 0x7a, 0xe5, 0x55, 0x81, 0xe0, 0x4e, 0xc2, 0xa0, 0x16, 0xeb, 0x9b, 0x5e, 0x0f, 0x3d,
0x82, 0x75, 0x4d, 0x2c, 0xe5, 0x4b, 0x62, 0xf4, 0x2a, 0x96, 0xa4, 0x1e, 0x2b, 0xa6, 0x1e, 0xab,
0x15, 0x5b, 0x38, 0x13, 0x63, 0xf3, 0x3e, 0x14, 0x35, 0x3e, 0x0a, 0xf0, 0x8f, 0x00, 0xe4, 0x1d,
0x48, 0xe0, 0xb3, 0x2e, 0x24, 0x11, 0x3c, 0xe6, 0x43, 0xd8, 0x52, 0x1e, 0x92, 0x71, 0x12, 0xb8,
0x26, 0x61, 0x33, 0xd2, 0xb0, 0x99, 0xf7, 0x60, 0x3b, 0xe5, 0xa8, 0x0e, 0xdc, 0x82, 0x55, 0xc9,
0x68, 0x8a, 0x4f, 0xc4, 0x87, 0x69, 0xc3, 0x66, 0x93, 0x63, 0x4e, 0xa2, 0x8b, 0x96, 0xcc, 0x2d,
0xaa, 0x9f, 0x88, 0xfb, 0x19, 0xe7, 0xc6, 0x62, 0x33, 0xf3, 0x31, 0x6c, 0xc8, 0xa1, 0xd6, 0x0e,
0x77, 0xa0, 0x94, 0x44, 0x35, 0x51, 0x52, 0x31, 0x21, 0x17, 0x85, 0xfd, 0x64, 0x00, 0xd4, 0x18,
0xf3, 0x7a, 0xfe, 0x90, 0xf8, 0x3c, 0x3a, 0x2a, 0x18, 0xb5, 0x07, 0x5e, 0xc7, 0x3d, 0x23, 0xe7,
0xf1, 0x51, 0x52, 0xf2, 0x82, 0x9c, 0xcf, 0x1f, 0xe1, 0x68, 0x34, 0x64, 0x58, 0x12, 0xba, 0xe2,
0xc6, 0x48, 0xc2, 0xc9, 0xc7, 0xc2, 0x66, 0xc4, 0xe5, 0xb7, 0xa0, 0x10, 0x28, 0x20, 0xa4, 0xd1,
0x8a, 0x34, 0x8a, 0x85, 0x91, 0x91, 0xf9, 0x29, 0x6c, 0xbf, 0x9a, 0x62, 0xf6, 0x18, 0xe7, 0x8b,
0xf3, 0x8a, 0x68, 0x3b, 0xed, 0x77, 0x21, 0xcc, 0x6d, 0xd8, 0xd3, 0xf6, 0x82, 0x0d, 0x27, 0x10,
0xb0, 0x44, 0x6b, 0x25, 0x0b, 0x8b, 0x9b, 0x17, 0xb7, 0x56, 0x88, 0xc4, 0x5d, 0x4d, 0xe5, 0xb4,
0x94, 0xce, 0xa9, 0x07, 0x37, 0x2f, 0x38, 0x43, 0xa5, 0x57, 0x07, 0xc0, 0x5a, 0x2c, 0x62, 0xe4,
0x6c, 0xd3, 0x9a, 0xbf, 0x95, 0xad, 0x49, 0x00, 0x27, 0xe1, 0x65, 0x12, 0xd8, 0x51, 0xdc, 0xf9,
0x94, 0x04, 0x94, 0x79, 0x89, 0xf0, 0x5f, 0x41, 0x29, 0xe6, 0xcd, 0xae, 0xd2, 0x29, 0xce, 0xdc,
0xcd, 0xe2, 0x4c, 0x15, 0xc3, 0x29, 0x06, 0xd3, 0x31, 0xcd, 0x97, 0x50, 0x6a, 0xf0, 0xfe, 0xc1,
0x53, 0xcc, 0xb1, 0x8e, 0xff, 0x04, 0xd6, 0x09, 0xef, 0x1f, 0xb8, 0x5d, 0xcc, 0xb1, 0x40, 0x28,
0x67, 0xef, 0x65, 0x05, 0xd6, 0xce, 0x6b, 0x44, 0xfd, 0xba, 0x5b, 0x87, 0x82, 0x86, 0xc8, 0xa1,
0x03, 0x82, 0x72, 0x70, 0xf9, 0xeb, 0xe3, 0x17, 0xc7, 0x27, 0xaf, 0x8f, 0x4b, 0x1f, 0xa0, 0x3c,
0xac, 0xd5, 0x5a, 0xad, 0x46, 0xb3, 0xd5, 0x70, 0x4a, 0x46, 0xf4, 0x75, 0xea, 0x9c, 0x9c, 0x9e,
0x34, 0x1b, 0x4e, 0x69, 0x09, 0xad, 0xc1, 0x4a, 0xfd, 0xa4, 0xf5, 0xac, 0xb4, 0x6c, 0xff, 0xb6,
0x0c, 0x85, 0xba, 0x38, 0xa8, 0x29, 0xdf, 0x36, 0xe8, 0x1b, 0xd8, 0x7c, 0x8d, 0x3d, 0xfe, 0x05,
0x0d, 0x27, 0xc4, 0x8a, 0xae, 0xce, 0x30, 0x43, 0x23, 0x7a, 0xb1, 0x54, 0xee, 0x66, 0x81, 0x3d,
0x4b, 0xca, 0xf7, 0x0d, 0x74, 0x04, 0x85, 0x43, 0xec, 0x53, 0xdf, 0xeb, 0xe0, 0xc1, 0x33, 0x82,
0xbb, 0x99, 0x61, 0x33, 0x57, 0x52, 0x7d, 0xb2, 0xf1, 0x91, 0x03, 0x9b, 0x47, 0x62, 0x0f, 0x26,
0x76, 0xd2, 0xbf, 0x8f, 0x98, 0x70, 0xbe, 0x6f, 0xa0, 0x6f, 0xa1, 0x98, 0x1a, 0x86, 0xcc, 0x88,
0xd5, 0xac, 0xd2, 0xb3, 0xa6, 0xe9, 0x08, 0xd6, 0xe2, 0x26, 0x66, 0x06, 0xdd, 0xcf, 0x0a, 0x9a,
0x9e, 0x1d, 0xfb, 0x6f, 0x03, 0x8a, 0xb5, 0x98, 0x21, 0x74, 0xeb, 0x40, 0x8a, 0x04, 0xb8, 0x8b,
0x94, 0x5c, 0xf9, 0x38, 0xf3, 0xb6, 0x4c, 0x73, 0xe2, 0x5b, 0xd8, 0x4e, 0x3d, 0xd4, 0x6a, 0x5c,
0x10, 0x93, 0x75, 0x71, 0x80, 0xf4, 0x43, 0x30, 0x1b, 0xb6, 0x8c, 0x77, 0xa0, 0xfd, 0xeb, 0xb2,
0x5e, 0x37, 0xba, 0xd0, 0x01, 0x14, 0xa6, 0xd6, 0x02, 0xfa, 0x24, 0xb3, 0x19, 0x73, 0xd6, 0x4e,
0xe5, 0xde, 0x82, 0xd6, 0xaa, 0xf6, 0x36, 0x5c, 0x99, 0xf3, 0xba, 0xca, 0xec, 0xe1, 0x83, 0xf7,
0x0c, 0xc6, 0xdc, 0x27, 0xda, 0x77, 0x90, 0x57, 0x87, 0xcb, 0xe1, 0x5e, 0xe4, 0x06, 0x54, 0x6e,
0xbf, 0xa7, 0x8e, 0x44, 0x05, 0xd1, 0x3f, 0x86, 0x60, 0xc4, 0x89, 0x5e, 0x8f, 0x8b, 0x9d, 0x70,
0x27, 0xeb, 0x84, 0x99, 0x35, 0x6b, 0xff, 0xb8, 0x0c, 0x25, 0x4d, 0x47, 0x71, 0xa3, 0x28, 0x6c,
0x4c, 0x6f, 0x16, 0x94, 0x89, 0xfd, 0xdc, 0xcd, 0x55, 0xb1, 0x16, 0x35, 0x57, 0x95, 0xfe, 0x6c,
0xc0, 0xb5, 0xcc, 0xbd, 0x81, 0x1e, 0xbd, 0x37, 0x5a, 0xc6, 0x3a, 0xab, 0x7c, 0xf6, 0x1f, 0x3c,
0x55, 0x4a, 0x14, 0xca, 0xda, 0x48, 0x3f, 0x7a, 0xd5, 0xed, 0xc9, 0xbc, 0xef, 0xe9, 0xe7, 0x74,
0x76, 0x27, 0x66, 0xde, 0xd1, 0xf5, 0xfc, 0x1f, 0xef, 0x6e, 0x18, 0x7f, 0xbe, 0xbb, 0x61, 0xfc,
0xf5, 0xee, 0x86, 0xd1, 0xbe, 0x24, 0xc6, 0xf3, 0xc1, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xcc,
0x6b, 0x9c, 0xfd, 0xd1, 0x0e, 0x00, 0x00,
}

2
proto/beacon/rpc/v1/services.proto
View File

@@ -77,7 +77,7 @@ message ChainStartResponse {
message ProposeRequest {
bytes parent_hash = 1;
uint64 slot_number = 2;
bytes randao_reveal_hash32 = 3;
bytes randao_reveal = 3;
bytes attestation_bitmask = 4;
repeated uint64 attestation_aggregate_sig = 5;
google.protobuf.Timestamp timestamp = 6;

16
shared/bls/bls.go
View File

@@ -54,6 +54,16 @@ func PublicKeyFromBytes(pub []byte) (*PublicKey, error) {
return &PublicKey{val: k}, nil
}
// SignatureFromBytes creates a BLS signature from a byte slice.
func SignatureFromBytes(sig []byte) (*Signature, error) {
b := bytesutil.ToBytes48(sig)
s, err := gobls.DeserializeSignature(b)
if err != nil {
return nil, fmt.Errorf("could not unmarshal bytes into signature: %v", err)
}
return &Signature{val: s}, nil
}
// PublicKey obtains the public key corresponding to the BLS secret key.
func (s *SecretKey) PublicKey() *PublicKey {
return &PublicKey{val: gobls.PrivToPub(s.val)}
@@ -100,6 +110,12 @@ func (s *Signature) VerifyAggregate(pubKeys []*PublicKey, msg []byte, domain uin
return s.val.VerifyAggregateCommon(keys, msg, domain)
}
// Marshal a signature into a byte slice.
func (s *Signature) Marshal() []byte {
k := s.val.Serialize()
return k[:]
}
// AggregateSignatures converts a list of signatures into a single, aggregated sig.
func AggregateSignatures(sigs []*Signature) *Signature {
var ss []*gobls.Signature

27
shared/params/config.go
View File

@@ -6,13 +6,6 @@ import (
"math/big"
)
func makeEmptySignature() [][]byte {
signature := make([][]byte, 2)
signature[0] = make([]byte, 48)
signature[1] = make([]byte, 48)
return signature
}
// BeaconChainConfig contains constant configs for node to participate in beacon chain.
type BeaconChainConfig struct {
// Misc constants.
@@ -30,6 +23,14 @@ type BeaconChainConfig struct {
WithdrawalPrivkeyFileName string // WithdrawalPrivKeyFileName specifies the string name of a withdrawal private key file.
BLSPubkeyLength int // BLSPubkeyLength defines the expected length of BLS public keys in bytes.
// BLS domain values.
DomainDeposit uint64 // DomainDeposit defines the BLS signature domain for deposit verification.
DomainAttestation uint64 // DomainAttestation defines the BLS signature domain for attestation verification.
DomainProposal uint64 // DomainProposal defines the BLS signature domain for proposal verification.
DomainExit uint64 // DomainExit defines the BLS signature domain for exit verification.
DomainRandao uint64 // DomainRandao defines the BLS signature domain for randao verification.
DomainTransfer uint64 // DomainTransfer defines the BLS signature domain for transfer verification.
// Deposit contract constants.
DepositContractAddress []byte // DepositContractAddress is the address of the deposit contract in PoW chain.
DepositContractTreeDepth uint64 // Depth of the Merkle trie of deposits in the validator deposit contract on the PoW chain.
@@ -46,7 +47,7 @@ type BeaconChainConfig struct {
GenesisEpoch uint64 // GenesisEpoch is used to initialize epoch.
GenesisStartShard uint64 // GenesisStartShard is the first shard to assign validators.
ZeroHash [32]byte // ZeroHash is used to represent a zeroed out 32 byte array.
EmptySignature [][]byte // EmptySignature is used to represent a zeroed out BLS Signature.
EmptySignature [96]byte // EmptySignature is used to represent a zeroed out BLS Signature.
BLSWithdrawalPrefixByte byte // BLSWithdrawalPrefixByte is used for BLS withdrawal and it's the first byte.
// Time parameters constants.
@@ -110,6 +111,14 @@ var defaultBeaconConfig = &BeaconChainConfig{
WithdrawalPrivkeyFileName: "/shardwithdrawalkey",
BLSPubkeyLength: 96,
// BLS domain values.
DomainDeposit: 0,
DomainAttestation: 1,
DomainProposal: 2,
DomainExit: 3,
DomainRandao: 4,
DomainTransfer: 5,
// Deposit contract constants.
DepositContractTreeDepth: 32,
@@ -126,7 +135,7 @@ var defaultBeaconConfig = &BeaconChainConfig{
GenesisStartShard: 0,
FarFutureEpoch: 1<<64 - 1,
ZeroHash: [32]byte{},
EmptySignature: makeEmptySignature(),
EmptySignature: [96]byte{},
// Time parameter constants.
SecondsPerSlot: 6,

8
validator/client/validator_propose.go
View File

@@ -59,10 +59,10 @@ func (v *validator) ProposeBlock(ctx context.Context, slot uint64) {
// 2. Construct block.
block := &pbp2p.BeaconBlock{
Slot: slot,
ParentRootHash32: parentTreeHash[:],
RandaoRevealHash32: nil, // TODO(1366): generate randao reveal from BLS
Eth1Data: eth1DataResp.Eth1Data,
Slot: slot,
ParentRootHash32: parentTreeHash[:],
RandaoReveal: nil, // TODO(1366): generate randao reveal from BLS
Eth1Data: eth1DataResp.Eth1Data,
Body: &pbp2p.BeaconBlockBody{
Attestations: attResp.PendingAttestations,
ProposerSlashings: nil, // TODO(1438): Add after operations pool