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

Update ChainHead (#4053)

Browse Source 
* Can build

* All tests pass

* Update beacon-chain/blockchain/chain_info.go

* Fix context

* Update chainhead

* Tests

* Tests

* e2e

* Update ordering

* Typo

* Use root to get slot

* Division
This commit is contained in:
terence tsao
2019-11-19 11:33:13 -08:00
committed by Raul Jordan
parent 26da7c4114
commit 7a22e98c0f
22 changed files with 519 additions and 289 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
WORKSPACE
View File

@@ -1199,7 +1199,7 @@ go_repository(
go_repository(
name = "com_github_prysmaticlabs_ethereumapis",
commit = "4220be00b4eeb50d10d9d4535accb5568bd94f3a",
commit = "4de8622eca7e6c4ff3cdf3c0db679e7fb8d57c0c",
importpath = "github.com/prysmaticlabs/ethereumapis",
)

41
beacon-chain/rpc/beacon/blocks.go
View File

@@ -6,6 +6,7 @@ import (
ptypes "github.com/gogo/protobuf/types"
"github.com/prysmaticlabs/go-ssz"
"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
"github.com/prysmaticlabs/prysm/beacon-chain/db/filters"
ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
"github.com/prysmaticlabs/prysm/shared/bytesutil"
@@ -148,20 +149,48 @@ func (bs *Server) ListBlocks(
func (bs *Server) GetChainHead(ctx context.Context, _ *ptypes.Empty) (*ethpb.ChainHead, error) {
headState, err := bs.HeadFetcher.HeadState(ctx)
if err != nil {
return nil, status.Errorf(codes.InvalidArgument, "Could not get head state")
return nil, status.Errorf(codes.Internal, "Could not get head state: %v", err)
}
headBlock := bs.HeadFetcher.HeadBlock()
headBlockRoot, err := ssz.SigningRoot(headBlock)
if err != nil {
return nil, status.Errorf(codes.Internal, "Could not get head block root: %v", err)
}
finalizedCheckpoint := headState.FinalizedCheckpoint
b, err := bs.BeaconDB.Block(ctx, bytesutil.ToBytes32(finalizedCheckpoint.Root))
if err != nil || b == nil {
return nil, status.Error(codes.Internal, "Could not get finalized block")
}
finalizedBlockSlot := b.Slot
justifiedCheckpoint := headState.CurrentJustifiedCheckpoint
b, err = bs.BeaconDB.Block(ctx, bytesutil.ToBytes32(justifiedCheckpoint.Root))
if err != nil || b == nil {
return nil, status.Error(codes.Internal, "Could not get justified block")
}
justifiedBlockSlot := b.Slot
prevJustifiedCheckpoint := headState.PreviousJustifiedCheckpoint
b, err = bs.BeaconDB.Block(ctx, bytesutil.ToBytes32(prevJustifiedCheckpoint.Root))
if err != nil || b == nil {
return nil, status.Error(codes.Internal, "Could not get prev justified block")
}
prevJustifiedBlockSlot := b.Slot
return &ethpb.ChainHead{
BlockRoot: bs.HeadFetcher.HeadRoot(),
BlockSlot: bs.HeadFetcher.HeadSlot(),
HeadBlockSlot: headBlock.Slot,
HeadBlockEpoch: helpers.SlotToEpoch(headBlock.Slot),
HeadBlockRoot: headBlockRoot[:],
FinalizedBlockRoot: finalizedCheckpoint.Root,
FinalizedSlot: finalizedCheckpoint.Epoch * params.BeaconConfig().SlotsPerEpoch,
FinalizedBlockSlot: finalizedBlockSlot,
FinalizedEpoch: finalizedCheckpoint.Epoch,
JustifiedBlockRoot: justifiedCheckpoint.Root,
JustifiedSlot: justifiedCheckpoint.Epoch * params.BeaconConfig().SlotsPerEpoch,
JustifiedBlockSlot: justifiedBlockSlot,
JustifiedEpoch: justifiedCheckpoint.Epoch,
PreviousJustifiedBlockRoot: prevJustifiedCheckpoint.Root,
PreviousJustifiedSlot: prevJustifiedCheckpoint.Epoch * params.BeaconConfig().SlotsPerEpoch,
PreviousJustifiedSlot: prevJustifiedBlockSlot,
PreviousJustifiedEpoch: prevJustifiedCheckpoint.Epoch,
}, nil
}

91
beacon-chain/rpc/beacon/blocks_test.go
View File

@@ -1,6 +1,7 @@
package beacon
import (
"bytes"
"context"
"fmt"
"strconv"
@@ -9,7 +10,9 @@ import (
"github.com/gogo/protobuf/proto"
"github.com/prysmaticlabs/go-ssz"
mock "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing"
dbTest "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
pbp2p "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
"github.com/prysmaticlabs/prysm/shared/params"
)
@@ -233,3 +236,91 @@ func TestServer_ListBlocks_Errors(t *testing.T) {
}
}
func TestServer_GetChainHead_NoFinalizedBlock(t *testing.T) {
db := dbTest.SetupDB(t)
defer dbTest.TeardownDB(t, db)
s := &pbp2p.BeaconState{
PreviousJustifiedCheckpoint: &ethpb.Checkpoint{Epoch: 3, Root: []byte{'A'}},
CurrentJustifiedCheckpoint: &ethpb.Checkpoint{Epoch: 2, Root: []byte{'B'}},
FinalizedCheckpoint: &ethpb.Checkpoint{Epoch: 1, Root: []byte{'C'}},
}
bs := &Server{
BeaconDB: db,
HeadFetcher: &mock.ChainService{Block: &ethpb.BeaconBlock{}, State: s},
}
if _, err := bs.GetChainHead(context.Background(), nil); !strings.Contains(err.Error(), "Could not get finalized block") {
t.Fatal("Did not get wanted error")
}
}
func TestServer_GetChainHead(t *testing.T) {
db := dbTest.SetupDB(t)
defer dbTest.TeardownDB(t, db)
finalizedBlock := &ethpb.BeaconBlock{Slot: 1, ParentRoot: []byte{'A'}}
db.SaveBlock(context.Background(), finalizedBlock)
fRoot, _ := ssz.SigningRoot(finalizedBlock)
justifiedBlock := &ethpb.BeaconBlock{Slot: 2, ParentRoot: []byte{'B'}}
db.SaveBlock(context.Background(), justifiedBlock)
jRoot, _ := ssz.SigningRoot(justifiedBlock)
prevJustifiedBlock := &ethpb.BeaconBlock{Slot: 3, ParentRoot: []byte{'C'}}
db.SaveBlock(context.Background(), prevJustifiedBlock)
pjRoot, _ := ssz.SigningRoot(prevJustifiedBlock)
s := &pbp2p.BeaconState{
PreviousJustifiedCheckpoint: &ethpb.Checkpoint{Epoch: 3, Root: pjRoot[:]},
CurrentJustifiedCheckpoint: &ethpb.Checkpoint{Epoch: 2, Root: jRoot[:]},
FinalizedCheckpoint: &ethpb.Checkpoint{Epoch: 1, Root: fRoot[:]},
}
b := &ethpb.BeaconBlock{Slot: s.PreviousJustifiedCheckpoint.Epoch*params.BeaconConfig().SlotsPerEpoch + 1}
bs := &Server{
BeaconDB: db,
HeadFetcher: &mock.ChainService{Block: b, State: s},
}
head, err := bs.GetChainHead(context.Background(), nil)
if err != nil {
t.Fatal(err)
}
if head.PreviousJustifiedEpoch != 3 {
t.Errorf("Wanted PreviousJustifiedEpoch: %d, got: %d",
3*params.BeaconConfig().SlotsPerEpoch, head.PreviousJustifiedEpoch)
}
if head.JustifiedEpoch != 2 {
t.Errorf("Wanted JustifiedEpoch: %d, got: %d",
2*params.BeaconConfig().SlotsPerEpoch, head.JustifiedEpoch)
}
if head.FinalizedEpoch != 1 {
t.Errorf("Wanted FinalizedEpoch: %d, got: %d",
1*params.BeaconConfig().SlotsPerEpoch, head.FinalizedEpoch)
}
if head.PreviousJustifiedSlot != 3 {
t.Errorf("Wanted PreviousJustifiedSlot: %d, got: %d",
3, head.PreviousJustifiedSlot)
}
if head.JustifiedBlockSlot != 2 {
t.Errorf("Wanted JustifiedSlot: %d, got: %d",
2, head.JustifiedBlockSlot)
}
if head.FinalizedBlockSlot != 1 {
t.Errorf("Wanted FinalizedSlot: %d, got: %d",
1, head.FinalizedBlockSlot)
}
if !bytes.Equal(pjRoot[:], head.PreviousJustifiedBlockRoot) {
t.Errorf("Wanted PreviousJustifiedBlockRoot: %v, got: %v",
pjRoot[:], head.PreviousJustifiedBlockRoot)
}
if !bytes.Equal(jRoot[:], head.JustifiedBlockRoot) {
t.Errorf("Wanted JustifiedBlockRoot: %v, got: %v",
jRoot[:], head.JustifiedBlockRoot)
}
if !bytes.Equal(fRoot[:], head.FinalizedBlockRoot) {
t.Errorf("Wanted FinalizedBlockRoot: %v, got: %v",
fRoot[:], head.FinalizedBlockRoot)
}
}

40
beacon-chain/rpc/beacon/validators_test.go
View File

@@ -1,7 +1,6 @@
package beacon
import (
"bytes"
"context"
"fmt"
"reflect"
@@ -1084,45 +1083,6 @@ func TestServer_GetValidatorParticipation_CurrentEpoch(t *testing.T) {
}
}
func TestServer_GetChainHead(t *testing.T) {
s := &pbp2p.BeaconState{
PreviousJustifiedCheckpoint: &ethpb.Checkpoint{Epoch: 3, Root: []byte{'A'}},
CurrentJustifiedCheckpoint: &ethpb.Checkpoint{Epoch: 2, Root: []byte{'B'}},
FinalizedCheckpoint: &ethpb.Checkpoint{Epoch: 1, Root: []byte{'C'}},
}
bs := &Server{HeadFetcher: &mock.ChainService{State: s}}
head, err := bs.GetChainHead(context.Background(), nil)
if err != nil {
t.Fatal(err)
}
if head.PreviousJustifiedSlot != 3*params.BeaconConfig().SlotsPerEpoch {
t.Errorf("Wanted PreviousJustifiedSlot: %d, got: %d",
3*params.BeaconConfig().SlotsPerEpoch, head.PreviousJustifiedSlot)
}
if head.JustifiedSlot != 2*params.BeaconConfig().SlotsPerEpoch {
t.Errorf("Wanted JustifiedSlot: %d, got: %d",
2*params.BeaconConfig().SlotsPerEpoch, head.JustifiedSlot)
}
if head.FinalizedSlot != 1*params.BeaconConfig().SlotsPerEpoch {
t.Errorf("Wanted FinalizedSlot: %d, got: %d",
1*params.BeaconConfig().SlotsPerEpoch, head.FinalizedSlot)
}
if !bytes.Equal([]byte{'A'}, head.PreviousJustifiedBlockRoot) {
t.Errorf("Wanted PreviousJustifiedBlockRoot: %v, got: %v",
[]byte{'A'}, head.PreviousJustifiedBlockRoot)
}
if !bytes.Equal([]byte{'B'}, head.JustifiedBlockRoot) {
t.Errorf("Wanted JustifiedBlockRoot: %v, got: %v",
[]byte{'B'}, head.JustifiedBlockRoot)
}
if !bytes.Equal([]byte{'C'}, head.FinalizedBlockRoot) {
t.Errorf("Wanted FinalizedBlockRoot: %v, got: %v",
[]byte{'C'}, head.FinalizedBlockRoot)
}
}
func setupValidators(t *testing.T, db db.Database, count int) ([]*ethpb.Validator, []uint64) {
ctx := context.Background()
balances := make([]uint64, count)

9
endtoend/evaluators/finality.go
View File

@@ -7,7 +7,6 @@ import (
ptypes "github.com/gogo/protobuf/types"
"github.com/pkg/errors"
eth "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
"github.com/prysmaticlabs/prysm/shared/params"
)
// FinalizationOccurs is an evaluator to make sure finalization is performing as it should.
@@ -23,8 +22,8 @@ func finalizationOccurs(client eth.BeaconChainClient) error {
if err != nil {
return errors.Wrap(err, "failed to get chain head")
}
currentEpoch := chainHead.BlockSlot / params.BeaconConfig().SlotsPerEpoch
finalizedEpoch := chainHead.FinalizedSlot / params.BeaconConfig().SlotsPerEpoch
currentEpoch := chainHead.HeadBlockEpoch
finalizedEpoch := chainHead.FinalizedEpoch
expectedFinalizedEpoch := currentEpoch - 2
if expectedFinalizedEpoch != finalizedEpoch {
@@ -34,8 +33,8 @@ func finalizationOccurs(client eth.BeaconChainClient) error {
finalizedEpoch,
)
}
previousJustifiedEpoch := chainHead.PreviousJustifiedSlot / params.BeaconConfig().SlotsPerEpoch
currentJustifiedEpoch := chainHead.JustifiedSlot / params.BeaconConfig().SlotsPerEpoch
previousJustifiedEpoch := chainHead.PreviousJustifiedEpoch
currentJustifiedEpoch := chainHead.JustifiedEpoch
if previousJustifiedEpoch+1 != currentJustifiedEpoch {
return fmt.Errorf(
"there should be no gaps between current and previous justified epochs, received current %d and previous %d",

5
proto/beacon/db/attestation_container.pb.go generated
View File

@@ -5,13 +5,12 @@ package db
import (
fmt "fmt"
io "io"
math "math"
_ "github.com/gogo/protobuf/gogoproto"
proto "github.com/gogo/protobuf/proto"
github_com_prysmaticlabs_go_bitfield "github.com/prysmaticlabs/go-bitfield"
v1alpha1 "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
io "io"
math "math"
)
// Reference imports to suppress errors if they are not otherwise used.

3
proto/beacon/db/finalized_block_root_container.pb.go generated
View File

@@ -5,10 +5,9 @@ package db
import (
fmt "fmt"
proto "github.com/gogo/protobuf/proto"
io "io"
math "math"
proto "github.com/gogo/protobuf/proto"
)
// Reference imports to suppress errors if they are not otherwise used.

5
proto/beacon/p2p/v1/messages.pb.go generated
View File

@@ -5,11 +5,10 @@ package ethereum_beacon_p2p_v1
import (
fmt "fmt"
io "io"
math "math"
_ "github.com/gogo/protobuf/gogoproto"
proto "github.com/gogo/protobuf/proto"
io "io"
math "math"
)
// Reference imports to suppress errors if they are not otherwise used.

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

@@ -5,13 +5,12 @@ package ethereum_beacon_p2p_v1
import (
fmt "fmt"
io "io"
math "math"
_ "github.com/gogo/protobuf/gogoproto"
proto "github.com/gogo/protobuf/proto"
github_com_prysmaticlabs_go_bitfield "github.com/prysmaticlabs/go-bitfield"
v1alpha1 "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
io "io"
math "math"
)
// Reference imports to suppress errors if they are not otherwise used.

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

@@ -7,14 +7,13 @@ import (
context "context"
encoding_binary "encoding/binary"
fmt "fmt"
io "io"
math "math"
proto "github.com/gogo/protobuf/proto"
types "github.com/gogo/protobuf/types"
v1alpha1 "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
_ "google.golang.org/genproto/googleapis/api/annotations"
grpc "google.golang.org/grpc"
io "io"
math "math"
)
// Reference imports to suppress errors if they are not otherwise used.

3
proto/beacon/rpc/v1_gateway/services.pb.go generated
View File

@@ -6,8 +6,6 @@ package ethereum_beacon_rpc_v1
import (
context "context"
fmt "fmt"
math "math"
proto "github.com/golang/protobuf/proto"
empty "github.com/golang/protobuf/ptypes/empty"
v1alpha1 "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
@@ -15,6 +13,7 @@ import (
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
math "math"
)
// Reference imports to suppress errors if they are not otherwise used.

10
proto/cluster/services.pb.go generated
View File

@@ -10,6 +10,8 @@ import (
proto "github.com/golang/protobuf/proto"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
)
// Reference imports to suppress errors if they are not otherwise used.
@@ -222,6 +224,14 @@ type PrivateKeyServiceServer interface {
Request(context.Context, *PrivateKeyRequest) (*PrivateKeyResponse, error)
}
// UnimplementedPrivateKeyServiceServer can be embedded to have forward compatible implementations.
type UnimplementedPrivateKeyServiceServer struct {
}
func (*UnimplementedPrivateKeyServiceServer) Request(ctx context.Context, req *PrivateKeyRequest) (*PrivateKeyResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Request not implemented")
}
func RegisterPrivateKeyServiceServer(s *grpc.Server, srv PrivateKeyServiceServer) {
s.RegisterService(&_PrivateKeyService_serviceDesc, srv)
}

5
proto/eth/v1alpha1/archive.pb.go generated
View File

@@ -5,11 +5,10 @@ package eth
import (
fmt "fmt"
io "io"
math "math"
_ "github.com/gogo/protobuf/gogoproto"
proto "github.com/gogo/protobuf/proto"
io "io"
math "math"
)
// Reference imports to suppress errors if they are not otherwise used.

5
proto/eth/v1alpha1/attestation.pb.go generated
View File

@@ -5,12 +5,11 @@ package eth
import (
fmt "fmt"
io "io"
math "math"
_ "github.com/gogo/protobuf/gogoproto"
proto "github.com/gogo/protobuf/proto"
github_com_prysmaticlabs_go_bitfield "github.com/prysmaticlabs/go-bitfield"
io "io"
math "math"
)
// Reference imports to suppress errors if they are not otherwise used.

5
proto/eth/v1alpha1/beacon_block.pb.go generated
View File

@@ -5,11 +5,10 @@ package eth
import (
fmt "fmt"
io "io"
math "math"
_ "github.com/gogo/protobuf/gogoproto"
proto "github.com/gogo/protobuf/proto"
io "io"
math "math"
)
// Reference imports to suppress errors if they are not otherwise used.

479
proto/eth/v1alpha1/beacon_chain.pb.go generated
View File

@@ -6,14 +6,13 @@ package eth
import (
context "context"
fmt "fmt"
io "io"
math "math"
_ "github.com/gogo/protobuf/gogoproto"
proto "github.com/gogo/protobuf/proto"
types "github.com/gogo/protobuf/types"
_ "google.golang.org/genproto/googleapis/api/annotations"
grpc "google.golang.org/grpc"
io "io"
math "math"
)
// Reference imports to suppress errors if they are not otherwise used.
@@ -645,14 +644,18 @@ func (m *BeaconBlockContainer) GetBlockRoot() []byte {
}
type ChainHead struct {
BlockRoot []byte `protobuf:"bytes,1,opt,name=block_root,json=blockRoot,proto3" json:"block_root,omitempty" ssz-size:"32"`
BlockSlot uint64 `protobuf:"varint,2,opt,name=block_slot,json=blockSlot,proto3" json:"block_slot,omitempty"`
FinalizedSlot uint64 `protobuf:"varint,3,opt,name=finalized_slot,json=finalizedSlot,proto3" json:"finalized_slot,omitempty"`
FinalizedBlockRoot []byte `protobuf:"bytes,4,opt,name=finalized_block_root,json=finalizedBlockRoot,proto3" json:"finalized_block_root,omitempty" ssz-size:"32"`
JustifiedSlot uint64 `protobuf:"varint,5,opt,name=justified_slot,json=justifiedSlot,proto3" json:"justified_slot,omitempty"`
JustifiedBlockRoot []byte `protobuf:"bytes,6,opt,name=justified_block_root,json=justifiedBlockRoot,proto3" json:"justified_block_root,omitempty" ssz-size:"32"`
PreviousJustifiedSlot uint64 `protobuf:"varint,7,opt,name=previous_justified_slot,json=previousJustifiedSlot,proto3" json:"previous_justified_slot,omitempty"`
PreviousJustifiedBlockRoot []byte `protobuf:"bytes,8,opt,name=previous_justified_block_root,json=previousJustifiedBlockRoot,proto3" json:"previous_justified_block_root,omitempty" ssz-size:"32"`
HeadBlockRoot []byte `protobuf:"bytes,1,opt,name=head_block_root,json=headBlockRoot,proto3" json:"head_block_root,omitempty" ssz-size:"32"`
HeadBlockSlot uint64 `protobuf:"varint,2,opt,name=head_block_slot,json=headBlockSlot,proto3" json:"head_block_slot,omitempty"`
HeadBlockEpoch uint64 `protobuf:"varint,3,opt,name=head_block_epoch,json=headBlockEpoch,proto3" json:"head_block_epoch,omitempty"`
FinalizedBlockSlot uint64 `protobuf:"varint,4,opt,name=finalized_block_slot,json=finalizedBlockSlot,proto3" json:"finalized_block_slot,omitempty"`
FinalizedEpoch uint64 `protobuf:"varint,5,opt,name=finalized_epoch,json=finalizedEpoch,proto3" json:"finalized_epoch,omitempty"`
FinalizedBlockRoot []byte `protobuf:"bytes,6,opt,name=finalized_block_root,json=finalizedBlockRoot,proto3" json:"finalized_block_root,omitempty" ssz-size:"32"`
JustifiedBlockSlot uint64 `protobuf:"varint,7,opt,name=justified_block_slot,json=justifiedBlockSlot,proto3" json:"justified_block_slot,omitempty"`
JustifiedEpoch uint64 `protobuf:"varint,8,opt,name=justified_epoch,json=justifiedEpoch,proto3" json:"justified_epoch,omitempty"`
JustifiedBlockRoot []byte `protobuf:"bytes,9,opt,name=justified_block_root,json=justifiedBlockRoot,proto3" json:"justified_block_root,omitempty" ssz-size:"32"`
PreviousJustifiedSlot uint64 `protobuf:"varint,10,opt,name=previous_justified_slot,json=previousJustifiedSlot,proto3" json:"previous_justified_slot,omitempty"`
PreviousJustifiedEpoch uint64 `protobuf:"varint,11,opt,name=previous_justified_epoch,json=previousJustifiedEpoch,proto3" json:"previous_justified_epoch,omitempty"`
PreviousJustifiedBlockRoot []byte `protobuf:"bytes,12,opt,name=previous_justified_block_root,json=previousJustifiedBlockRoot,proto3" json:"previous_justified_block_root,omitempty" ssz-size:"32"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@@ -691,23 +694,37 @@ func (m *ChainHead) XXX_DiscardUnknown() {
var xxx_messageInfo_ChainHead proto.InternalMessageInfo
func (m *ChainHead) GetBlockRoot() []byte {
func (m *ChainHead) GetHeadBlockRoot() []byte {
if m != nil {
return m.BlockRoot
return m.HeadBlockRoot
}
return nil
}
func (m *ChainHead) GetBlockSlot() uint64 {
func (m *ChainHead) GetHeadBlockSlot() uint64 {
if m != nil {
return m.BlockSlot
return m.HeadBlockSlot
}
return 0
}
func (m *ChainHead) GetFinalizedSlot() uint64 {
func (m *ChainHead) GetHeadBlockEpoch() uint64 {
if m != nil {
return m.FinalizedSlot
return m.HeadBlockEpoch
}
return 0
}
func (m *ChainHead) GetFinalizedBlockSlot() uint64 {
if m != nil {
return m.FinalizedBlockSlot
}
return 0
}
func (m *ChainHead) GetFinalizedEpoch() uint64 {
if m != nil {
return m.FinalizedEpoch
}
return 0
}
@@ -719,9 +736,16 @@ func (m *ChainHead) GetFinalizedBlockRoot() []byte {
return nil
}
func (m *ChainHead) GetJustifiedSlot() uint64 {
func (m *ChainHead) GetJustifiedBlockSlot() uint64 {
if m != nil {
return m.JustifiedSlot
return m.JustifiedBlockSlot
}
return 0
}
func (m *ChainHead) GetJustifiedEpoch() uint64 {
if m != nil {
return m.JustifiedEpoch
}
return 0
}
@@ -740,6 +764,13 @@ func (m *ChainHead) GetPreviousJustifiedSlot() uint64 {
return 0
}
func (m *ChainHead) GetPreviousJustifiedEpoch() uint64 {
if m != nil {
return m.PreviousJustifiedEpoch
}
return 0
}
func (m *ChainHead) GetPreviousJustifiedBlockRoot() []byte {
if m != nil {
return m.PreviousJustifiedBlockRoot
@@ -2507,118 +2538,122 @@ func init() {
}
var fileDescriptor_678c88b69c3c78d4 = []byte{
// 1773 bytes of a gzipped FileDescriptorProto
// 1827 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x59, 0xcd, 0x8f, 0x1b, 0x49,
0x15, 0x4f, 0xfb, 0x23, 0x33, 0x7e, 0x63, 0xcf, 0x47, 0x8d, 0x93, 0x18, 0x27, 0x99, 0x71, 0x7a,
0x36, 0x13, 0x47, 0x93, 0xd8, 0x3b, 0xb3, 0xc9, 0xb2, 0x5a, 0x84, 0x96, 0xb1, 0xb5, 0x64, 0x02,
0x11, 0x1a, 0x7a, 0x76, 0x39, 0x70, 0xb1, 0xda, 0xed, 0x1a, 0xbb, 0x76, 0xda, 0x5d, 0x1d, 0x77,
0x79, 0x94, 0x99, 0x1b, 0x1c, 0x90, 0x38, 0x23, 0x01, 0x27, 0xe0, 0xba, 0x5a, 0x71, 0xe1, 0xc0,
0x65, 0x25, 0x40, 0x9c, 0x38, 0x22, 0x21, 0x71, 0x5c, 0xa1, 0x08, 0x89, 0x13, 0x07, 0xf6, 0x2f,
0x40, 0x5d, 0x55, 0xdd, 0x5d, 0x6d, 0x77, 0xdb, 0x5e, 0x65, 0x0e, 0x88, 0x9b, 0xfb, 0xd5, 0xab,
0xdf, 0xfb, 0xd5, 0xfb, 0xa8, 0x7a, 0x55, 0x86, 0xfb, 0xee, 0x88, 0x32, 0xda, 0xc4, 0x6c, 0xd0,
0x3c, 0xdf, 0x37, 0x6d, 0x77, 0x60, 0xee, 0x37, 0xbb, 0xd8, 0xb4, 0xa8, 0xd3, 0xb1, 0x06, 0x26,
0x71, 0x1a, 0x7c, 0x1c, 0xdd, 0xc0, 0x6c, 0x80, 0x47, 0x78, 0x3c, 0x6c, 0x60, 0x36, 0x68, 0x04,
0x9a, 0xd5, 0xc7, 0x7d, 0xc2, 0x06, 0xe3, 0x6e, 0xc3, 0xa2, 0xc3, 0x66, 0x9f, 0xf6, 0x69, 0x93,
0x6b, 0x77, 0xc7, 0xa7, 0xfc, 0x4b, 0x40, 0xfb, 0xbf, 0x04, 0x4a, 0xf5, 0x4e, 0x9f, 0xd2, 0xbe,
0x8d, 0x9b, 0xa6, 0x4b, 0x9a, 0xa6, 0xe3, 0x50, 0x66, 0x32, 0x42, 0x1d, 0x4f, 0x8e, 0xde, 0x96,
0xa3, 0x21, 0x06, 0x1e, 0xba, 0xec, 0x42, 0x0e, 0xbe, 0x95, 0xc0, 0xd3, 0x64, 0x0c, 0x7b, 0x02,
0x43, 0x6a, 0xcd, 0x58, 0x4d, 0xd7, 0xa6, 0xd6, 0x99, 0x54, 0xd3, 0x13, 0xd4, 0xce, 0x4d, 0x9b,
0xf4, 0x4c, 0x46, 0x47, 0x42, 0x47, 0xff, 0x75, 0x06, 0x6e, 0xbd, 0x20, 0x1e, 0x3b, 0x8c, 0x8c,
0x78, 0x06, 0x7e, 0x39, 0xc6, 0x1e, 0x43, 0x75, 0x58, 0x1b, 0x60, 0xb3, 0x27, 0x30, 0x3b, 0x23,
0x4a, 0x59, 0x45, 0xab, 0x69, 0xf5, 0xe2, 0xd1, 0x35, 0xa3, 0xe4, 0x0f, 0xb4, 0x7c, 0xb9, 0x41,
0x29, 0x43, 0x3b, 0x50, 0xf4, 0xe8, 0x78, 0x64, 0xe1, 0x0e, 0x76, 0xa9, 0x35, 0xa8, 0x64, 0x6a,
0x5a, 0x3d, 0x77, 0x74, 0xcd, 0x58, 0x11, 0xd2, 0x0f, 0x7d, 0x21, 0xba, 0x07, 0xf2, 0x53, 0x40,
0x65, 0x25, 0x14, 0x08, 0x61, 0x80, 0xc3, 0xcc, 0x51, 0x1f, 0x33, 0x89, 0x93, 0x0b, 0x70, 0x84,
0x34, 0xc4, 0x91, 0x4a, 0x1c, 0x27, 0x1f, 0xe0, 0x08, 0x21, 0xc7, 0xb9, 0x0d, 0x05, 0xd7, 0xec,
0xe3, 0x8e, 0x47, 0x2e, 0x71, 0xe5, 0x7a, 0x4d, 0xab, 0xe7, 0x8d, 0x65, 0x5f, 0x70, 0x42, 0x2e,
0x31, 0xba, 0x0b, 0xc0, 0x07, 0x19, 0x3d, 0xc3, 0x4e, 0x65, 0xa9, 0xa6, 0xd5, 0x0b, 0x06, 0x57,
0xff, 0xc8, 0x17, 0xb4, 0x56, 0xa1, 0xf8, 0x72, 0x8c, 0x47, 0x17, 0x9d, 0x53, 0x62, 0x33, 0x3c,
0xd2, 0x3f, 0xd5, 0xa0, 0x32, 0xed, 0x21, 0xcf, 0xa5, 0x8e, 0x87, 0xd1, 0xb7, 0xa1, 0xa8, 0x84,
0xc7, 0xab, 0x68, 0xb5, 0x6c, 0x7d, 0xe5, 0x40, 0x6f, 0x24, 0xe6, 0x51, 0x43, 0x81, 0x30, 0x62,
0xf3, 0xd0, 0x2e, 0xac, 0x39, 0xf8, 0x15, 0xeb, 0x28, 0xc4, 0x32, 0x9c, 0x58, 0xc9, 0x17, 0x1f,
0x07, 0xe4, 0x7c, 0xee, 0x8c, 0x32, 0xd3, 0x16, 0x2b, 0xcb, 0xf2, 0x95, 0x15, 0xb8, 0xc4, 0x5f,
0x9a, 0xfe, 0x77, 0x0d, 0x36, 0x7c, 0xae, 0x3c, 0x32, 0x61, 0x1c, 0xcb, 0x90, 0x8b, 0x05, 0x8f,
0x7f, 0xf9, 0x52, 0xcf, 0xa6, 0x2c, 0x8c, 0x15, 0xff, 0x42, 0x37, 0x21, 0x2f, 0x5c, 0x9f, 0x95,
0x62, 0xf1, 0x89, 0xf6, 0xa1, 0x4c, 0x1c, 0xcb, 0x1e, 0xf7, 0x70, 0xc7, 0xa1, 0x8e, 0x65, 0x3a,
0xd4, 0x21, 0x96, 0x69, 0xf3, 0x08, 0x2d, 0x1b, 0x9b, 0x72, 0xec, 0x7b, 0xca, 0x50, 0x3c, 0x08,
0xf9, 0x99, 0x41, 0xb8, 0x3e, 0x2f, 0x08, 0xbf, 0xd3, 0x00, 0xa9, 0x0b, 0x93, 0xee, 0xff, 0x18,
0xd6, 0x78, 0x72, 0xb6, 0xa9, 0xc3, 0x4c, 0xe2, 0xe0, 0x51, 0x10, 0x81, 0xbd, 0x94, 0x08, 0xb4,
0x78, 0x95, 0xb4, 0x62, 0x73, 0x8c, 0x49, 0x8c, 0xab, 0x8a, 0x06, 0x85, 0x72, 0x92, 0x3d, 0xf4,
0x1e, 0xe4, 0xb9, 0x45, 0x1e, 0x90, 0xf4, 0x6c, 0x51, 0xe6, 0x1a, 0x62, 0x82, 0x6f, 0x50, 0x29,
0x46, 0x9f, 0x53, 0xd1, 0x28, 0x74, 0x83, 0x32, 0xd4, 0xff, 0x9c, 0x85, 0x42, 0xdb, 0xdf, 0xce,
0x8e, 0xb0, 0xd9, 0x43, 0x6f, 0xc7, 0x94, 0x79, 0xf0, 0x5b, 0x1b, 0x5f, 0x7e, 0xb1, 0x5d, 0xf2,
0xbc, 0xcb, 0xc7, 0x3e, 0xe3, 0xf7, 0xf5, 0x77, 0x0e, 0x74, 0x65, 0x7e, 0x04, 0x1f, 0x25, 0x86,
0x1c, 0x3e, 0xf1, 0x73, 0xe3, 0x3e, 0xac, 0x9e, 0x12, 0xc7, 0xb4, 0xc9, 0x25, 0xee, 0x09, 0x15,
0x9e, 0x24, 0x46, 0x29, 0x94, 0x72, 0xb5, 0x36, 0x94, 0x23, 0x35, 0x85, 0x41, 0x2e, 0x8d, 0x01,
0x0a, 0xd5, 0xa3, 0x1d, 0xe5, 0x3e, 0xac, 0x7e, 0x32, 0xf6, 0x18, 0x39, 0x25, 0x81, 0xad, 0xbc,
0xb0, 0x15, 0x4a, 0x03, 0x5b, 0x91, 0x9a, 0x62, 0xeb, 0x7a, 0xaa, 0xad, 0x50, 0x3d, 0xb2, 0xf5,
0x2e, 0xdc, 0x72, 0x47, 0xf8, 0x9c, 0xd0, 0xb1, 0xd7, 0x99, 0x30, 0xba, 0xc4, 0x8d, 0xde, 0x08,
0x86, 0xbf, 0x13, 0x33, 0xfe, 0x11, 0xdc, 0x4d, 0x98, 0xa7, 0xb0, 0x58, 0x4e, 0x63, 0x51, 0x9d,
0x02, 0x0c, 0xd9, 0xe8, 0xbf, 0xd0, 0xe0, 0x86, 0x9f, 0xea, 0x6d, 0x3a, 0x1c, 0x12, 0xc6, 0x30,
0x0e, 0xeb, 0x38, 0xac, 0x4d, 0x2d, 0x5e, 0x9b, 0x55, 0x58, 0xea, 0x63, 0x07, 0x7b, 0xc4, 0xe3,
0x31, 0x5b, 0x3e, 0xba, 0x66, 0x04, 0x82, 0x78, 0x11, 0x66, 0x67, 0x16, 0x61, 0x6e, 0x5e, 0x11,
0xfe, 0x31, 0x03, 0xeb, 0x22, 0x29, 0x23, 0x6e, 0xa8, 0x1c, 0x23, 0x15, 0x50, 0xfa, 0x18, 0xc0,
0x0a, 0x75, 0x2a, 0x19, 0x5e, 0x93, 0x4f, 0x67, 0xe6, 0x79, 0x04, 0xd9, 0x08, 0x7f, 0x3e, 0x67,
0x78, 0x68, 0x28, 0x40, 0xe8, 0x09, 0xdc, 0x34, 0x2d, 0x46, 0xce, 0x71, 0x27, 0x3c, 0xc7, 0x3a,
0x16, 0x1d, 0x3b, 0x41, 0x26, 0x96, 0xc5, 0xe8, 0x0f, 0x82, 0xc1, 0xb6, 0x3f, 0x96, 0x54, 0xce,
0xb9, 0xf9, 0xe5, 0x9c, 0x9f, 0x28, 0xe7, 0xea, 0x21, 0x94, 0x62, 0xcc, 0xd0, 0x1d, 0x28, 0x84,
0xdc, 0xf8, 0xbe, 0x93, 0x33, 0x22, 0x01, 0x42, 0xea, 0xfe, 0x2a, 0x76, 0x57, 0xfd, 0xdf, 0x1a,
0xdc, 0x7e, 0x86, 0x59, 0xc8, 0xaf, 0x65, 0xda, 0xa6, 0x63, 0xbd, 0x59, 0x84, 0x9f, 0xc0, 0x8a,
0x3b, 0xee, 0xda, 0xc4, 0xea, 0x9c, 0xe1, 0x0b, 0xaf, 0x92, 0xad, 0x65, 0xeb, 0xc5, 0xd6, 0xe6,
0x97, 0x5f, 0x6c, 0xaf, 0x45, 0x39, 0xf7, 0xc1, 0xa3, 0x27, 0xef, 0xe9, 0x06, 0x08, 0xbd, 0xef,
0xe2, 0x0b, 0x0f, 0x55, 0x60, 0x89, 0x38, 0x3d, 0x62, 0x61, 0xaf, 0x92, 0xe3, 0xcc, 0x83, 0xcf,
0x2b, 0xdd, 0xb6, 0x3f, 0xcb, 0xc0, 0xc6, 0xd4, 0x62, 0x53, 0x52, 0xe6, 0x05, 0x2c, 0x77, 0xa5,
0x86, 0x4c, 0x98, 0xb7, 0x53, 0x12, 0x66, 0x0a, 0xb1, 0x21, 0x7f, 0x18, 0x21, 0x42, 0x52, 0xcc,
0xb3, 0xf3, 0x63, 0x9e, 0x9b, 0x8c, 0xf9, 0x19, 0x2c, 0x49, 0x6c, 0x7f, 0x3b, 0x8d, 0xfc, 0x9c,
0xbc, 0x9d, 0xfa, 0x4e, 0x2e, 0x84, 0x4e, 0xf6, 0xd7, 0x49, 0x9c, 0x1e, 0x7e, 0x25, 0x53, 0x40,
0x7c, 0xf8, 0x9e, 0x97, 0x2c, 0x65, 0xd2, 0x06, 0x9f, 0xfa, 0xcf, 0x35, 0x28, 0xab, 0xd9, 0xf1,
0x3f, 0x53, 0xf8, 0x9f, 0x69, 0x00, 0x11, 0xab, 0x94, 0xf8, 0x7d, 0x0b, 0x20, 0x2c, 0xca, 0x20,
0x82, 0xb5, 0x79, 0x11, 0x34, 0x94, 0x39, 0x57, 0x14, 0x33, 0x9d, 0xc0, 0x8e, 0xea, 0xc5, 0x43,
0xbe, 0x25, 0x9c, 0x60, 0xd6, 0x1e, 0x98, 0x4e, 0xff, 0x8d, 0x6a, 0x6d, 0xca, 0x31, 0x7f, 0xc8,
0xc0, 0xfa, 0x24, 0x7e, 0x8a, 0x7b, 0x9e, 0xc1, 0x0d, 0xbe, 0x39, 0x99, 0x0c, 0xf7, 0x3a, 0x6a,
0xc1, 0x66, 0xd2, 0x0b, 0x76, 0x33, 0x9c, 0x71, 0x1c, 0x55, 0xee, 0x21, 0x20, 0xfc, 0x8a, 0x4c,
0xa2, 0xcc, 0x28, 0xfb, 0x75, 0xa1, 0xae, 0x40, 0xb4, 0x61, 0xd3, 0xb3, 0x4d, 0x6f, 0x30, 0x81,
0x91, 0x4b, 0xc7, 0xd8, 0x90, 0xfa, 0x71, 0x10, 0xfc, 0x09, 0xb6, 0x26, 0x89, 0xe4, 0x67, 0x80,
0x48, 0xfd, 0x08, 0x44, 0xff, 0x5c, 0x83, 0xd5, 0x30, 0x52, 0xdf, 0x1f, 0xe3, 0x31, 0x46, 0xdb,
0xb0, 0x62, 0x0d, 0xc6, 0x23, 0xa7, 0x63, 0x93, 0x21, 0x61, 0xd2, 0x89, 0xc0, 0x45, 0x2f, 0x7c,
0x09, 0x7a, 0x2e, 0x0f, 0x01, 0xde, 0x3a, 0x2f, 0xea, 0xca, 0x72, 0x34, 0x45, 0x59, 0xc3, 0x37,
0x81, 0x3b, 0x67, 0x51, 0x4f, 0xae, 0xfa, 0xca, 0x0a, 0xfb, 0xff, 0x68, 0xb0, 0xed, 0x1f, 0xd5,
0x51, 0xae, 0x79, 0x1e, 0xe9, 0x3b, 0x43, 0xec, 0xb0, 0xff, 0xdb, 0x2d, 0xfd, 0x4f, 0x59, 0x28,
0x27, 0xad, 0x37, 0x25, 0xed, 0x4d, 0x58, 0x31, 0x23, 0x25, 0xb9, 0x2d, 0x7c, 0x30, 0x6f, 0x5b,
0x50, 0x70, 0xa3, 0x6e, 0x20, 0x12, 0x1a, 0x2a, 0xe6, 0x55, 0x6d, 0xf5, 0xff, 0xd2, 0x60, 0x33,
0xc1, 0x16, 0xda, 0x83, 0x8d, 0xe0, 0xa5, 0x20, 0xea, 0x68, 0xc4, 0x69, 0xbf, 0xde, 0x9d, 0xec,
0x86, 0x1e, 0xc0, 0x5a, 0xa8, 0xd5, 0x51, 0x37, 0xff, 0xd5, 0x50, 0xfc, 0x9c, 0x9f, 0x02, 0x3b,
0x50, 0x12, 0x17, 0x40, 0x3c, 0x52, 0x5b, 0xe9, 0x62, 0x20, 0xe4, 0x0d, 0xe6, 0x0e, 0x94, 0xdc,
0x11, 0x75, 0xa9, 0x17, 0x28, 0xe5, 0x84, 0x52, 0x20, 0xe4, 0x4a, 0xf1, 0x73, 0x29, 0x3f, 0xff,
0x5c, 0xd2, 0x4f, 0xa1, 0xa6, 0x6e, 0x90, 0xc7, 0xe6, 0x88, 0x11, 0x8b, 0xb8, 0xe2, 0x5e, 0x7a,
0x85, 0xbb, 0xe3, 0xa7, 0x1a, 0x6c, 0xa5, 0x59, 0x91, 0x17, 0xb8, 0xe4, 0xa4, 0xb9, 0x03, 0x85,
0xf0, 0x4a, 0x20, 0xcc, 0x18, 0x91, 0x00, 0x9d, 0x40, 0xc9, 0x55, 0xc1, 0xb8, 0xeb, 0x56, 0x0e,
0x1e, 0xcf, 0x4b, 0xaa, 0x38, 0x83, 0x38, 0x86, 0x6e, 0xc2, 0x2d, 0xe5, 0x76, 0x7e, 0x4c, 0xa9,
0x7d, 0xd5, 0x77, 0xfc, 0x83, 0x5f, 0x96, 0x60, 0x45, 0xf6, 0xba, 0xfe, 0x1d, 0x0d, 0xfd, 0x4a,
0x83, 0xf5, 0xc9, 0x87, 0x05, 0xd4, 0x48, 0x81, 0x4d, 0x79, 0xa3, 0xa9, 0x36, 0x17, 0xd6, 0x17,
0xab, 0xd1, 0x1f, 0xfe, 0xf8, 0x6f, 0xff, 0xfc, 0x59, 0x66, 0x07, 0xdd, 0x4b, 0x7a, 0x3e, 0x6a,
0xc6, 0x1e, 0x25, 0x7e, 0xaa, 0xc1, 0xda, 0x84, 0x53, 0xd0, 0xcd, 0x86, 0x78, 0xbe, 0x6a, 0x04,
0xcf, 0x57, 0x8d, 0x0f, 0x87, 0x2e, 0xbb, 0xa8, 0x36, 0xe6, 0xbb, 0x43, 0x75, 0xaa, 0xde, 0xe0,
0x34, 0xea, 0x68, 0x77, 0x2e, 0x8d, 0xa6, 0xeb, 0xdb, 0xfd, 0x89, 0x06, 0x10, 0x3d, 0x00, 0xa0,
0xfa, 0x8c, 0x65, 0xc7, 0x1e, 0x3f, 0xaa, 0x0f, 0x17, 0xd0, 0x94, 0x9c, 0x76, 0x38, 0xa7, 0xbb,
0xe8, 0x76, 0x22, 0xa7, 0xae, 0xb0, 0xec, 0x42, 0xf1, 0x19, 0x3f, 0xeb, 0xe5, 0x2d, 0x3b, 0xcd,
0x21, 0x69, 0xad, 0x4f, 0x38, 0x53, 0xdf, 0xe5, 0xe6, 0x6a, 0x68, 0x2b, 0xd1, 0x1c, 0x7f, 0x96,
0x1c, 0xf8, 0x16, 0xfc, 0xb6, 0x90, 0xb3, 0x9d, 0xdc, 0x6c, 0x1e, 0xcd, 0x58, 0xda, 0xd4, 0xed,
0xb1, 0xfa, 0x60, 0xc1, 0xeb, 0x97, 0xfe, 0x80, 0xf3, 0xba, 0x87, 0xb6, 0x93, 0x79, 0x45, 0xf6,
0x7f, 0x23, 0x6f, 0xaa, 0xd3, 0x1d, 0xfe, 0x41, 0x8a, 0xad, 0x19, 0x77, 0x9f, 0x6a, 0x7d, 0xd1,
0x6e, 0x3f, 0x2d, 0x85, 0xa3, 0x4e, 0xb2, 0x19, 0x5e, 0x03, 0x7e, 0xa4, 0x41, 0x29, 0xd6, 0x52,
0xa3, 0xbd, 0x05, 0xa8, 0x85, 0x9c, 0xee, 0xcd, 0xe3, 0xe4, 0xe9, 0x35, 0x4e, 0xa6, 0x8a, 0x2a,
0x69, 0x64, 0xd0, 0xef, 0x35, 0xb8, 0x33, 0xab, 0x21, 0x45, 0xef, 0x2f, 0x40, 0x29, 0xa5, 0x8b,
0x4d, 0x8d, 0xea, 0xa4, 0xbe, 0xbe, 0xcf, 0x79, 0xee, 0xa1, 0x87, 0xa9, 0x4e, 0x13, 0x77, 0x67,
0x0f, 0x33, 0x4b, 0xf2, 0xba, 0x84, 0x0d, 0x95, 0x82, 0x68, 0xcf, 0xd2, 0xf2, 0xfd, 0xfe, 0x3c,
0x57, 0xf1, 0xe9, 0x69, 0x49, 0xaf, 0xd0, 0x78, 0xc9, 0xcd, 0xfc, 0x56, 0xbe, 0xba, 0x26, 0xb6,
0x1a, 0xef, 0xce, 0x48, 0xfc, 0x19, 0xbd, 0x58, 0x75, 0xef, 0x2b, 0xf4, 0x1d, 0xfa, 0x23, 0xce,
0x74, 0x17, 0xbd, 0x95, 0xee, 0x30, 0x85, 0xd2, 0xe7, 0x1a, 0x7c, 0x2d, 0xf5, 0x50, 0x45, 0x5f,
0x5f, 0x20, 0xc2, 0x49, 0xc7, 0x70, 0xf5, 0xe9, 0x57, 0x3b, 0xd4, 0xe6, 0xec, 0xae, 0x0a, 0xf7,
0xd8, 0xe9, 0xd7, 0x6a, 0xff, 0xe5, 0xf5, 0x96, 0xf6, 0xd7, 0xd7, 0x5b, 0xda, 0x3f, 0x5e, 0x6f,
0x69, 0x3f, 0x7c, 0xaa, 0xfc, 0xdd, 0xe1, 0x8e, 0x2e, 0xbc, 0xa1, 0xc9, 0x88, 0x65, 0x9b, 0x5d,
0x4f, 0x7c, 0x35, 0xa7, 0xff, 0x56, 0xf8, 0x06, 0x66, 0x83, 0xee, 0x75, 0x2e, 0x7f, 0xe7, 0xbf,
0x01, 0x00, 0x00, 0xff, 0xff, 0xbe, 0x47, 0x22, 0x14, 0x6c, 0x19, 0x00, 0x00,
0x15, 0x4f, 0xfb, 0x23, 0x33, 0x7e, 0xb6, 0xe7, 0xa3, 0xc6, 0x49, 0x8c, 0x93, 0xcc, 0x38, 0x3d,
0xbb, 0x13, 0x47, 0x93, 0xd8, 0xc9, 0x6c, 0xb2, 0x84, 0x45, 0x68, 0x19, 0x5b, 0x4b, 0x26, 0x10,
0xa1, 0xa1, 0x67, 0x97, 0x03, 0x17, 0xab, 0xdd, 0x53, 0x63, 0xd7, 0x4e, 0xbb, 0xab, 0xe3, 0x2e,
0x8f, 0x32, 0x73, 0x83, 0x03, 0x12, 0x67, 0x24, 0xe0, 0x04, 0x7b, 0x5d, 0xad, 0xb8, 0x70, 0xe0,
0xb2, 0x12, 0x70, 0xe4, 0x88, 0x84, 0xc4, 0x71, 0x85, 0x22, 0x24, 0x4e, 0x1c, 0xd8, 0xbf, 0x00,
0x75, 0x55, 0x75, 0x77, 0xb5, 0xdd, 0x6d, 0x7b, 0x95, 0x39, 0xa0, 0xbd, 0xb9, 0x5f, 0xbd, 0xfa,
0xd5, 0xaf, 0xde, 0x57, 0xbd, 0x2a, 0xc3, 0xdb, 0xee, 0x88, 0x32, 0xda, 0xc2, 0x6c, 0xd0, 0x3a,
0x7b, 0x64, 0xda, 0xee, 0xc0, 0x7c, 0xd4, 0xea, 0x61, 0xd3, 0xa2, 0x4e, 0xd7, 0x1a, 0x98, 0xc4,
0x69, 0xf2, 0x71, 0x74, 0x0d, 0xb3, 0x01, 0x1e, 0xe1, 0xf1, 0xb0, 0x89, 0xd9, 0xa0, 0x19, 0x68,
0xd6, 0x1e, 0xf4, 0x09, 0x1b, 0x8c, 0x7b, 0x4d, 0x8b, 0x0e, 0x5b, 0x7d, 0xda, 0xa7, 0x2d, 0xae,
0xdd, 0x1b, 0x9f, 0xf0, 0x2f, 0x01, 0xed, 0xff, 0x12, 0x28, 0xb5, 0x5b, 0x7d, 0x4a, 0xfb, 0x36,
0x6e, 0x99, 0x2e, 0x69, 0x99, 0x8e, 0x43, 0x99, 0xc9, 0x08, 0x75, 0x3c, 0x39, 0x7a, 0x53, 0x8e,
0x86, 0x18, 0x78, 0xe8, 0xb2, 0x73, 0x39, 0xf8, 0x56, 0x02, 0x4f, 0x93, 0x31, 0xec, 0x09, 0x0c,
0xa9, 0x35, 0x63, 0x37, 0x3d, 0x9b, 0x5a, 0xa7, 0x52, 0x4d, 0x4f, 0x50, 0x3b, 0x33, 0x6d, 0x72,
0x6c, 0x32, 0x3a, 0x12, 0x3a, 0xfa, 0xef, 0x32, 0x70, 0xe3, 0x05, 0xf1, 0xd8, 0x7e, 0xb4, 0x88,
0x67, 0xe0, 0x97, 0x63, 0xec, 0x31, 0xd4, 0x80, 0xd5, 0x01, 0x36, 0x8f, 0x05, 0x66, 0x77, 0x44,
0x29, 0xab, 0x6a, 0x75, 0xad, 0x51, 0x3a, 0xb8, 0x62, 0x94, 0xfd, 0x81, 0xb6, 0x2f, 0x37, 0x28,
0x65, 0x68, 0x1b, 0x4a, 0x1e, 0x1d, 0x8f, 0x2c, 0xdc, 0xc5, 0x2e, 0xb5, 0x06, 0xd5, 0x4c, 0x5d,
0x6b, 0xe4, 0x0e, 0xae, 0x18, 0x45, 0x21, 0xfd, 0xc0, 0x17, 0xa2, 0x3b, 0x20, 0x3f, 0x05, 0x54,
0x56, 0x42, 0x81, 0x10, 0x06, 0x38, 0xcc, 0x1c, 0xf5, 0x31, 0x93, 0x38, 0xb9, 0x00, 0x47, 0x48,
0x43, 0x1c, 0xa9, 0xc4, 0x71, 0xf2, 0x01, 0x8e, 0x10, 0x72, 0x9c, 0x9b, 0x50, 0x70, 0xcd, 0x3e,
0xee, 0x7a, 0xe4, 0x02, 0x57, 0xaf, 0xd6, 0xb5, 0x46, 0xde, 0x58, 0xf6, 0x05, 0x47, 0xe4, 0x02,
0xa3, 0xdb, 0x00, 0x7c, 0x90, 0xd1, 0x53, 0xec, 0x54, 0x97, 0xea, 0x5a, 0xa3, 0x60, 0x70, 0xf5,
0x0f, 0x7d, 0x41, 0x7b, 0x05, 0x4a, 0x2f, 0xc7, 0x78, 0x74, 0xde, 0x3d, 0x21, 0x36, 0xc3, 0x23,
0xfd, 0x53, 0x0d, 0xaa, 0xd3, 0x16, 0xf2, 0x5c, 0xea, 0x78, 0x18, 0x7d, 0x0f, 0x4a, 0x8a, 0x7b,
0xbc, 0xaa, 0x56, 0xcf, 0x36, 0x8a, 0x7b, 0x7a, 0x33, 0x31, 0x8e, 0x9a, 0x0a, 0x84, 0x11, 0x9b,
0x87, 0x76, 0x60, 0xd5, 0xc1, 0xaf, 0x58, 0x57, 0x21, 0x96, 0xe1, 0xc4, 0xca, 0xbe, 0xf8, 0x30,
0x20, 0xe7, 0x73, 0x67, 0x94, 0x99, 0xb6, 0xd8, 0x59, 0x96, 0xef, 0xac, 0xc0, 0x25, 0xfe, 0xd6,
0xf4, 0x7f, 0x68, 0xb0, 0xee, 0x73, 0xe5, 0x9e, 0x09, 0xfd, 0x58, 0x81, 0x5c, 0xcc, 0x79, 0xfc,
0xcb, 0x97, 0x7a, 0x36, 0x65, 0xa1, 0xaf, 0xf8, 0x17, 0xba, 0x0e, 0x79, 0x61, 0xfa, 0xac, 0x14,
0x8b, 0x4f, 0xf4, 0x08, 0x2a, 0xc4, 0xb1, 0xec, 0xf1, 0x31, 0xee, 0x3a, 0xd4, 0xb1, 0x4c, 0x87,
0x3a, 0xc4, 0x32, 0x6d, 0xee, 0xa1, 0x65, 0x63, 0x43, 0x8e, 0xfd, 0x50, 0x19, 0x8a, 0x3b, 0x21,
0x3f, 0xd3, 0x09, 0x57, 0xe7, 0x39, 0xe1, 0x0f, 0x1a, 0x20, 0x75, 0x63, 0xd2, 0xfc, 0x1f, 0xc1,
0x2a, 0x0f, 0xce, 0x0e, 0x75, 0x98, 0x49, 0x1c, 0x3c, 0x0a, 0x3c, 0xb0, 0x9b, 0xe2, 0x81, 0x36,
0xcf, 0x92, 0x76, 0x6c, 0x8e, 0x31, 0x89, 0x71, 0x59, 0xde, 0xa0, 0x50, 0x49, 0x5a, 0x0f, 0x3d,
0x85, 0x3c, 0x5f, 0x91, 0x3b, 0x24, 0x3d, 0x5a, 0x94, 0xb9, 0x86, 0x98, 0xe0, 0x2f, 0xa8, 0x24,
0xa3, 0xcf, 0xa9, 0x64, 0x14, 0x7a, 0x41, 0x1a, 0xea, 0x9f, 0xe4, 0xa1, 0xd0, 0xf1, 0xcb, 0xd9,
0x01, 0x36, 0x8f, 0xd1, 0xb7, 0x52, 0xd2, 0xb7, 0xbd, 0xfe, 0xe5, 0x17, 0x5b, 0x65, 0xcf, 0xbb,
0x78, 0xe0, 0xd3, 0x7e, 0x4f, 0x7f, 0x67, 0x4f, 0x9f, 0xcc, 0xe7, 0x9d, 0xd8, 0xd4, 0x28, 0x4c,
0x14, 0xbd, 0x23, 0x3f, 0x5a, 0x1a, 0xb0, 0xa6, 0xe8, 0x29, 0x81, 0x63, 0xac, 0x84, 0x8a, 0x22,
0x69, 0x1f, 0x42, 0xe5, 0x84, 0x38, 0xa6, 0x4d, 0x2e, 0x70, 0x0c, 0x96, 0x67, 0xb8, 0x81, 0xc2,
0xb1, 0x08, 0xfb, 0x2e, 0xac, 0x46, 0x33, 0x04, 0x74, 0x5e, 0x40, 0x87, 0x62, 0x01, 0xdd, 0x99,
0x86, 0xe6, 0x9b, 0xbd, 0x9a, 0xb6, 0xd9, 0x89, 0xd5, 0xf8, 0x8e, 0x1f, 0x42, 0xe5, 0xe3, 0xb1,
0xc7, 0xc8, 0x09, 0x89, 0xf3, 0x5b, 0x12, 0xfc, 0xc2, 0xb1, 0x18, 0xbf, 0x68, 0x86, 0xe0, 0xb7,
0x2c, 0xf8, 0x85, 0xe2, 0x90, 0xdf, 0x24, 0x34, 0xe7, 0x57, 0x48, 0xe5, 0x17, 0x5f, 0x8d, 0xf3,
0x7b, 0x17, 0x6e, 0xb8, 0x23, 0x7c, 0x46, 0xe8, 0xd8, 0xeb, 0x46, 0x68, 0x9c, 0x22, 0xf0, 0x55,
0xaf, 0x05, 0xc3, 0xdf, 0x0f, 0x46, 0x39, 0xcb, 0xa7, 0x50, 0x4d, 0x98, 0x27, 0xe8, 0x16, 0xf9,
0xc4, 0xeb, 0x53, 0x13, 0x05, 0xed, 0x0f, 0xe1, 0x76, 0xc2, 0x4c, 0x85, 0x7f, 0x29, 0x8d, 0x7f,
0x6d, 0x0a, 0x31, 0xdc, 0x87, 0xfe, 0x6b, 0x0d, 0xae, 0xf9, 0x89, 0xdc, 0xa1, 0xc3, 0x21, 0x61,
0x0c, 0xe3, 0xb0, 0x4a, 0x85, 0x95, 0x47, 0x8b, 0x57, 0x9e, 0x1a, 0x2c, 0xf5, 0xb1, 0x83, 0x3d,
0xe2, 0xf1, 0x18, 0x5c, 0x3e, 0xb8, 0x62, 0x04, 0x82, 0x78, 0x89, 0xc9, 0xce, 0x2c, 0x31, 0xb9,
0x79, 0x25, 0xe6, 0xcf, 0x19, 0x58, 0x13, 0x29, 0x17, 0x71, 0x43, 0x95, 0x18, 0xa9, 0x80, 0xd2,
0x47, 0x00, 0x56, 0xa8, 0x53, 0xcd, 0xf0, 0x8a, 0xf3, 0x64, 0x66, 0x16, 0x47, 0x90, 0xcd, 0xf0,
0xe7, 0x73, 0x86, 0x87, 0x86, 0x02, 0x84, 0x1e, 0xc3, 0x75, 0xd3, 0x62, 0xe4, 0x0c, 0x77, 0xc3,
0x53, 0xba, 0x6b, 0xd1, 0xb1, 0xc3, 0x64, 0x4e, 0x55, 0xc4, 0xe8, 0x8f, 0x83, 0xc1, 0x8e, 0x3f,
0x96, 0x54, 0xac, 0x72, 0xf3, 0x8b, 0x55, 0x7e, 0xa2, 0x58, 0xd5, 0xf6, 0xa1, 0x1c, 0x63, 0x86,
0x6e, 0x41, 0x21, 0xe4, 0xc6, 0xab, 0x6a, 0xce, 0x88, 0x04, 0x08, 0xa9, 0xa7, 0x87, 0x38, 0x3b,
0xf4, 0xff, 0x68, 0x70, 0xf3, 0x19, 0x66, 0x21, 0xbf, 0xb6, 0x69, 0x9b, 0x8e, 0xf5, 0x66, 0x1e,
0x7e, 0x0c, 0x45, 0x77, 0xdc, 0xb3, 0x89, 0xd5, 0x3d, 0xc5, 0xe7, 0x5e, 0x35, 0x5b, 0xcf, 0x36,
0x4a, 0xed, 0x8d, 0x2f, 0xbf, 0xd8, 0x5a, 0x8d, 0x62, 0xee, 0xfd, 0xfb, 0x8f, 0x9f, 0xea, 0x06,
0x08, 0xbd, 0x1f, 0xe0, 0x73, 0x0f, 0x55, 0x61, 0x89, 0x38, 0xc7, 0xc4, 0xc2, 0x5e, 0x35, 0xc7,
0x99, 0x07, 0x9f, 0x97, 0x7a, 0x28, 0x7d, 0x96, 0x81, 0xf5, 0xa9, 0xcd, 0xa6, 0x84, 0xcc, 0x0b,
0x58, 0xee, 0x49, 0x0d, 0x19, 0x30, 0x0f, 0x53, 0x02, 0x66, 0x0a, 0xb1, 0x29, 0x7f, 0x18, 0x21,
0x42, 0x92, 0xcf, 0xb3, 0xf3, 0x7d, 0x9e, 0x9b, 0xf4, 0xf9, 0x29, 0x2c, 0x49, 0x6c, 0xf4, 0x10,
0x20, 0xb2, 0x73, 0xf2, 0x39, 0xe1, 0x1b, 0xb9, 0x10, 0x1a, 0xd9, 0xdf, 0x27, 0x71, 0x8e, 0xf1,
0x2b, 0x19, 0x02, 0xe2, 0xc3, 0xb7, 0xbc, 0x64, 0x29, 0x83, 0x36, 0xf8, 0xd4, 0x7f, 0xa5, 0x41,
0x45, 0x8d, 0x8e, 0xff, 0x9b, 0xc4, 0xff, 0x4c, 0x03, 0x88, 0x58, 0xa5, 0xf8, 0xef, 0xbb, 0x00,
0x61, 0x52, 0x06, 0x1e, 0xac, 0xcf, 0xf3, 0xa0, 0xa1, 0xcc, 0xb9, 0x24, 0x9f, 0xe9, 0x04, 0xb6,
0x55, 0x2b, 0xee, 0xf3, 0x92, 0x70, 0x84, 0x59, 0x67, 0x60, 0x3a, 0xfd, 0x37, 0xca, 0xb5, 0x29,
0xc3, 0xfc, 0x29, 0x03, 0x6b, 0x93, 0xf8, 0x29, 0xe6, 0x79, 0x06, 0xd7, 0x78, 0x71, 0x32, 0x19,
0x3e, 0xee, 0xaa, 0x09, 0x9b, 0x49, 0x4f, 0xd8, 0x8d, 0x70, 0xc6, 0x61, 0x94, 0xb9, 0xfb, 0x80,
0xf0, 0x2b, 0x32, 0x89, 0x32, 0x23, 0xed, 0xd7, 0x84, 0xba, 0x02, 0xd1, 0x81, 0x0d, 0xcf, 0x36,
0xbd, 0xc1, 0x04, 0x46, 0x2e, 0x1d, 0x63, 0x5d, 0xea, 0xc7, 0x41, 0xf0, 0xc7, 0xd8, 0x9a, 0x24,
0x92, 0x9f, 0x01, 0x22, 0xf5, 0x23, 0x10, 0xfd, 0x73, 0x0d, 0x56, 0x42, 0x4f, 0xfd, 0x68, 0x8c,
0xc7, 0x18, 0x6d, 0x41, 0xd1, 0x1a, 0x8c, 0x47, 0x4e, 0xd7, 0x26, 0x43, 0xc2, 0xa4, 0x11, 0x81,
0x8b, 0x5e, 0xf8, 0x12, 0xf4, 0x5c, 0x1e, 0x02, 0xfc, 0x62, 0xb0, 0xa8, 0x29, 0x2b, 0xd1, 0x14,
0x65, 0x0f, 0xdf, 0x01, 0x6e, 0x9c, 0x45, 0x2d, 0xb9, 0xe2, 0x2b, 0x2b, 0xec, 0xff, 0xab, 0xc1,
0x96, 0x7f, 0x54, 0x47, 0xb1, 0xe6, 0x79, 0xa4, 0xef, 0x0c, 0xb1, 0xc3, 0xbe, 0xb6, 0x25, 0xfd,
0x2f, 0x59, 0xa8, 0x24, 0xed, 0x37, 0x25, 0xec, 0x4d, 0x28, 0x9a, 0x91, 0x92, 0x2c, 0x0b, 0xef,
0xcf, 0x2b, 0x0b, 0x0a, 0x6e, 0xd4, 0x0d, 0x44, 0x42, 0x43, 0xc5, 0xbc, 0xac, 0x52, 0xff, 0x6f,
0x0d, 0x36, 0x12, 0xd6, 0x42, 0xbb, 0xb0, 0x1e, 0xbc, 0x83, 0x44, 0x1d, 0x8d, 0x38, 0xed, 0xd7,
0x7a, 0x93, 0xdd, 0xd0, 0x5d, 0x58, 0x0d, 0xb5, 0xba, 0x6a, 0xf1, 0x5f, 0x09, 0xc5, 0xcf, 0xf9,
0x29, 0xb0, 0x0d, 0x65, 0x71, 0xbd, 0xc5, 0x23, 0xd1, 0xa3, 0x8a, 0xb3, 0xa0, 0x14, 0x08, 0x79,
0x6b, 0xba, 0x0d, 0x65, 0x77, 0x44, 0x5d, 0xea, 0x05, 0x4a, 0xe2, 0x2e, 0x50, 0x0a, 0x84, 0x5c,
0x29, 0x7e, 0x2e, 0xe5, 0xe7, 0x9f, 0x4b, 0xfa, 0x09, 0xd4, 0xd5, 0x02, 0x79, 0x68, 0x8e, 0x18,
0xb1, 0x88, 0x2b, 0x6e, 0xdd, 0x97, 0x58, 0x1d, 0x3f, 0xd5, 0x60, 0x33, 0x6d, 0x15, 0x79, 0x3d,
0x4d, 0x0e, 0x9a, 0x5b, 0x50, 0x08, 0x2f, 0x20, 0x62, 0x19, 0x23, 0x12, 0xa0, 0x23, 0x28, 0xbb,
0x2a, 0x18, 0x37, 0x5d, 0x71, 0xef, 0xc1, 0xbc, 0xa0, 0x8a, 0x33, 0x88, 0x63, 0xe8, 0x26, 0xdc,
0x50, 0xde, 0x1e, 0x0e, 0x29, 0xb5, 0x2f, 0xfb, 0x05, 0x63, 0xef, 0x37, 0x65, 0x28, 0xca, 0x5e,
0xd7, 0xbf, 0x81, 0xa2, 0xdf, 0x6a, 0xb0, 0x36, 0xf9, 0x6c, 0x82, 0x9a, 0x29, 0xb0, 0x29, 0x2f,
0x50, 0xb5, 0xd6, 0xc2, 0xfa, 0x62, 0x37, 0xfa, 0xbd, 0x9f, 0xfd, 0xfd, 0x5f, 0xbf, 0xcc, 0x6c,
0xa3, 0x3b, 0x49, 0x8f, 0x63, 0xad, 0xd8, 0x93, 0xcb, 0x2f, 0x34, 0x58, 0x9d, 0x30, 0x0a, 0xba,
0xde, 0x14, 0x8f, 0x73, 0xcd, 0xe0, 0x71, 0xae, 0xf9, 0xc1, 0xd0, 0x65, 0xe7, 0xb5, 0xe6, 0x7c,
0x73, 0xa8, 0x46, 0xd5, 0x9b, 0x9c, 0x46, 0x03, 0xed, 0xcc, 0xa5, 0xd1, 0x72, 0xfd, 0x75, 0x7f,
0xae, 0x01, 0x44, 0xcf, 0x1b, 0xa8, 0x31, 0x63, 0xdb, 0xb1, 0xa7, 0x9d, 0xda, 0xbd, 0x05, 0x34,
0x25, 0xa7, 0x6d, 0xce, 0xe9, 0x36, 0xba, 0x99, 0xc8, 0xa9, 0x27, 0x56, 0x76, 0xa1, 0xf4, 0x8c,
0x9f, 0xf5, 0xf2, 0x0d, 0x21, 0xcd, 0x20, 0x69, 0xad, 0x4f, 0x38, 0x53, 0xdf, 0xe1, 0xcb, 0xd5,
0xd1, 0x66, 0xe2, 0x72, 0xfc, 0xd1, 0x75, 0xe0, 0xaf, 0xe0, 0xb7, 0x85, 0x9c, 0xed, 0x64, 0xb1,
0xb9, 0x3f, 0x63, 0x6b, 0x53, 0xb7, 0xc7, 0xda, 0xdd, 0x05, 0xaf, 0x5f, 0xfa, 0x5d, 0xce, 0xeb,
0x0e, 0xda, 0x4a, 0xe6, 0x15, 0xad, 0xff, 0x89, 0xbc, 0xa9, 0x4e, 0x77, 0xf8, 0x7b, 0x29, 0x6b,
0xcd, 0xb8, 0xfb, 0xd4, 0x1a, 0x8b, 0x76, 0xfb, 0x69, 0x21, 0x1c, 0x75, 0x92, 0xad, 0xf0, 0x1a,
0xf0, 0x53, 0x0d, 0xca, 0xb1, 0x96, 0x1a, 0xed, 0x2e, 0x40, 0x2d, 0xe4, 0x74, 0x67, 0x1e, 0x27,
0x4f, 0xaf, 0x73, 0x32, 0x35, 0x54, 0x4d, 0x23, 0x83, 0xfe, 0xa8, 0xc1, 0xad, 0x59, 0x0d, 0x29,
0x7a, 0x6f, 0x01, 0x4a, 0x29, 0x5d, 0x6c, 0xaa, 0x57, 0x27, 0xf5, 0xf5, 0x47, 0x9c, 0xe7, 0x2e,
0xba, 0x97, 0x6a, 0x34, 0x71, 0x77, 0xf6, 0x30, 0xb3, 0x24, 0xaf, 0x0b, 0x58, 0x57, 0x29, 0x88,
0xf6, 0x2c, 0x2d, 0xde, 0xdf, 0x9e, 0x67, 0x2a, 0x3e, 0x3d, 0x2d, 0xe8, 0x15, 0x1a, 0x2f, 0xf9,
0x32, 0xbf, 0x97, 0x6f, 0xca, 0x89, 0xad, 0xc6, 0xbb, 0x33, 0x02, 0x7f, 0x46, 0x2f, 0x56, 0xdb,
0xfd, 0x0a, 0x7d, 0x87, 0x7e, 0x9f, 0x33, 0xdd, 0x41, 0x6f, 0xa5, 0x1b, 0x4c, 0xa1, 0xf4, 0xb9,
0x06, 0xdf, 0x48, 0x3d, 0x54, 0xd1, 0x37, 0x17, 0xf0, 0x70, 0xd2, 0x31, 0x5c, 0x7b, 0xf2, 0xd5,
0x0e, 0xb5, 0x39, 0xd5, 0x55, 0xe1, 0x1e, 0x3b, 0xfd, 0xda, 0x9d, 0xbf, 0xbe, 0xde, 0xd4, 0xfe,
0xf6, 0x7a, 0x53, 0xfb, 0xe7, 0xeb, 0x4d, 0xed, 0x27, 0x4f, 0x94, 0x3f, 0x73, 0xdc, 0xd1, 0xb9,
0x37, 0x34, 0x19, 0xb1, 0x6c, 0xb3, 0xe7, 0x89, 0xaf, 0xd6, 0xf4, 0x9f, 0x26, 0xdf, 0xc6, 0x6c,
0xd0, 0xbb, 0xca, 0xe5, 0xef, 0xfc, 0x2f, 0x00, 0x00, 0xff, 0xff, 0xfb, 0x74, 0xd9, 0xa3, 0x4a,
0x1a, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@@ -3319,46 +3354,66 @@ func (m *ChainHead) MarshalTo(dAtA []byte) (int, error) {
_ = i
var l int
_ = l
if len(m.BlockRoot) > 0 {
if len(m.HeadBlockRoot) > 0 {
dAtA[i] = 0xa
i++
i = encodeVarintBeaconChain(dAtA, i, uint64(len(m.BlockRoot)))
i += copy(dAtA[i:], m.BlockRoot)
i = encodeVarintBeaconChain(dAtA, i, uint64(len(m.HeadBlockRoot)))
i += copy(dAtA[i:], m.HeadBlockRoot)
}
if m.BlockSlot != 0 {
if m.HeadBlockSlot != 0 {
dAtA[i] = 0x10
i++
i = encodeVarintBeaconChain(dAtA, i, uint64(m.BlockSlot))
i = encodeVarintBeaconChain(dAtA, i, uint64(m.HeadBlockSlot))
}
if m.FinalizedSlot != 0 {
if m.HeadBlockEpoch != 0 {
dAtA[i] = 0x18
i++
i = encodeVarintBeaconChain(dAtA, i, uint64(m.FinalizedSlot))
i = encodeVarintBeaconChain(dAtA, i, uint64(m.HeadBlockEpoch))
}
if m.FinalizedBlockSlot != 0 {
dAtA[i] = 0x20
i++
i = encodeVarintBeaconChain(dAtA, i, uint64(m.FinalizedBlockSlot))
}
if m.FinalizedEpoch != 0 {
dAtA[i] = 0x28
i++
i = encodeVarintBeaconChain(dAtA, i, uint64(m.FinalizedEpoch))
}
if len(m.FinalizedBlockRoot) > 0 {
dAtA[i] = 0x22
dAtA[i] = 0x32
i++
i = encodeVarintBeaconChain(dAtA, i, uint64(len(m.FinalizedBlockRoot)))
i += copy(dAtA[i:], m.FinalizedBlockRoot)
}
if m.JustifiedSlot != 0 {
dAtA[i] = 0x28
if m.JustifiedBlockSlot != 0 {
dAtA[i] = 0x38
i++
i = encodeVarintBeaconChain(dAtA, i, uint64(m.JustifiedSlot))
i = encodeVarintBeaconChain(dAtA, i, uint64(m.JustifiedBlockSlot))
}
if m.JustifiedEpoch != 0 {
dAtA[i] = 0x40
i++
i = encodeVarintBeaconChain(dAtA, i, uint64(m.JustifiedEpoch))
}
if len(m.JustifiedBlockRoot) > 0 {
dAtA[i] = 0x32
dAtA[i] = 0x4a
i++
i = encodeVarintBeaconChain(dAtA, i, uint64(len(m.JustifiedBlockRoot)))
i += copy(dAtA[i:], m.JustifiedBlockRoot)
}
if m.PreviousJustifiedSlot != 0 {
dAtA[i] = 0x38
dAtA[i] = 0x50
i++
i = encodeVarintBeaconChain(dAtA, i, uint64(m.PreviousJustifiedSlot))
}
if m.PreviousJustifiedEpoch != 0 {
dAtA[i] = 0x58
i++
i = encodeVarintBeaconChain(dAtA, i, uint64(m.PreviousJustifiedEpoch))
}
if len(m.PreviousJustifiedBlockRoot) > 0 {
dAtA[i] = 0x42
dAtA[i] = 0x62
i++
i = encodeVarintBeaconChain(dAtA, i, uint64(len(m.PreviousJustifiedBlockRoot)))
i += copy(dAtA[i:], m.PreviousJustifiedBlockRoot)
@@ -4480,22 +4535,31 @@ func (m *ChainHead) Size() (n int) {
}
var l int
_ = l
l = len(m.BlockRoot)
l = len(m.HeadBlockRoot)
if l > 0 {
n += 1 + l + sovBeaconChain(uint64(l))
}
if m.BlockSlot != 0 {
n += 1 + sovBeaconChain(uint64(m.BlockSlot))
if m.HeadBlockSlot != 0 {
n += 1 + sovBeaconChain(uint64(m.HeadBlockSlot))
}
if m.FinalizedSlot != 0 {
n += 1 + sovBeaconChain(uint64(m.FinalizedSlot))
if m.HeadBlockEpoch != 0 {
n += 1 + sovBeaconChain(uint64(m.HeadBlockEpoch))
}
if m.FinalizedBlockSlot != 0 {
n += 1 + sovBeaconChain(uint64(m.FinalizedBlockSlot))
}
if m.FinalizedEpoch != 0 {
n += 1 + sovBeaconChain(uint64(m.FinalizedEpoch))
}
l = len(m.FinalizedBlockRoot)
if l > 0 {
n += 1 + l + sovBeaconChain(uint64(l))
}
if m.JustifiedSlot != 0 {
n += 1 + sovBeaconChain(uint64(m.JustifiedSlot))
if m.JustifiedBlockSlot != 0 {
n += 1 + sovBeaconChain(uint64(m.JustifiedBlockSlot))
}
if m.JustifiedEpoch != 0 {
n += 1 + sovBeaconChain(uint64(m.JustifiedEpoch))
}
l = len(m.JustifiedBlockRoot)
if l > 0 {
@@ -4504,6 +4568,9 @@ func (m *ChainHead) Size() (n int) {
if m.PreviousJustifiedSlot != 0 {
n += 1 + sovBeaconChain(uint64(m.PreviousJustifiedSlot))
}
if m.PreviousJustifiedEpoch != 0 {
n += 1 + sovBeaconChain(uint64(m.PreviousJustifiedEpoch))
}
l = len(m.PreviousJustifiedBlockRoot)
if l > 0 {
n += 1 + l + sovBeaconChain(uint64(l))
@@ -5951,7 +6018,7 @@ func (m *ChainHead) Unmarshal(dAtA []byte) error {
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field BlockRoot", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field HeadBlockRoot", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
@@ -5978,16 +6045,16 @@ func (m *ChainHead) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.BlockRoot = append(m.BlockRoot[:0], dAtA[iNdEx:postIndex]...)
if m.BlockRoot == nil {
m.BlockRoot = []byte{}
m.HeadBlockRoot = append(m.HeadBlockRoot[:0], dAtA[iNdEx:postIndex]...)
if m.HeadBlockRoot == nil {
m.HeadBlockRoot = []byte{}
}
iNdEx = postIndex
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field BlockSlot", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field HeadBlockSlot", wireType)
}
m.BlockSlot = 0
m.HeadBlockSlot = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBeaconChain
@@ -5997,16 +6064,16 @@ func (m *ChainHead) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
m.BlockSlot |= uint64(b&0x7F) << shift
m.HeadBlockSlot |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 3:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field FinalizedSlot", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field HeadBlockEpoch", wireType)
}
m.FinalizedSlot = 0
m.HeadBlockEpoch = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBeaconChain
@@ -6016,12 +6083,50 @@ func (m *ChainHead) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
m.FinalizedSlot |= uint64(b&0x7F) << shift
m.HeadBlockEpoch |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 4:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field FinalizedBlockSlot", wireType)
}
m.FinalizedBlockSlot = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBeaconChain
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.FinalizedBlockSlot |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 5:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field FinalizedEpoch", wireType)
}
m.FinalizedEpoch = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBeaconChain
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.FinalizedEpoch |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 6:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field FinalizedBlockRoot", wireType)
}
@@ -6055,11 +6160,11 @@ func (m *ChainHead) Unmarshal(dAtA []byte) error {
m.FinalizedBlockRoot = []byte{}
}
iNdEx = postIndex
case 5:
case 7:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field JustifiedSlot", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field JustifiedBlockSlot", wireType)
}
m.JustifiedSlot = 0
m.JustifiedBlockSlot = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBeaconChain
@@ -6069,12 +6174,31 @@ func (m *ChainHead) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
m.JustifiedSlot |= uint64(b&0x7F) << shift
m.JustifiedBlockSlot |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 6:
case 8:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field JustifiedEpoch", wireType)
}
m.JustifiedEpoch = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBeaconChain
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.JustifiedEpoch |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 9:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field JustifiedBlockRoot", wireType)
}
@@ -6108,7 +6232,7 @@ func (m *ChainHead) Unmarshal(dAtA []byte) error {
m.JustifiedBlockRoot = []byte{}
}
iNdEx = postIndex
case 7:
case 10:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field PreviousJustifiedSlot", wireType)
}
@@ -6127,7 +6251,26 @@ func (m *ChainHead) Unmarshal(dAtA []byte) error {
break
}
}
case 8:
case 11:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field PreviousJustifiedEpoch", wireType)
}
m.PreviousJustifiedEpoch = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBeaconChain
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.PreviousJustifiedEpoch |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 12:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field PreviousJustifiedBlockRoot", wireType)
}

61
proto/eth/v1alpha1/beacon_chain.proto
View File

@@ -46,11 +46,11 @@ service BeaconChain {
};
}
// Retrieve blocks by root, slot, or epoch.
//
// Retrieve blocks by root, slot, or epoch.
//
// The server may return multiple blocks in the case that a slot or epoch is
// provided as the filter criteria. The server may return an empty list when
// no blocks in their database match the filter criteria. This RPC should
// no blocks in their database match the filter criteria. This RPC should
// not return NOT_FOUND. Only one filter criteria should be used.
rpc ListBlocks(ListBlocksRequest) returns (ListBlocksResponse) {
option (google.api.http) = {
@@ -59,8 +59,8 @@ service BeaconChain {
}
// Retrieve information about the head of the beacon chain from the view of
// the beacon chain node.
//
// the beacon chain node.
//
// This includes the head block slot and root as well as information about
// the most recent finalized and justified slots.
rpc GetChainHead(google.protobuf.Empty) returns (ChainHead) {
@@ -79,17 +79,17 @@ service BeaconChain {
};
}
// Retrieve validator balances for a given set of public keys at a specific
// Retrieve validator balances for a given set of public keys at a specific
// epoch in time.
rpc ListValidatorBalances(GetValidatorBalancesRequest) returns (ValidatorBalances) {
rpc ListValidatorBalances(GetValidatorBalancesRequest) returns (ValidatorBalances) {
option (google.api.http) = {
get: "/eth/v1alpha1/validators/balances"
};
}
// Retrieve the current list of active validators.
// Retrieve the current list of active validators.
//
// The request may include an optional historical epoch to retrieve a
// The request may include an optional historical epoch to retrieve a
// specific validator set in time.
rpc GetValidators(GetValidatorsRequest) returns (Validators) {
option (google.api.http) = {
@@ -97,8 +97,8 @@ service BeaconChain {
};
}
// Retrieve the active set changes for a given epoch.
//
// Retrieve the active set changes for a given epoch.
//
// This data includes any activations, voluntary exits, and involuntary
// ejections.
rpc GetValidatorActiveSetChanges(GetValidatorActiveSetChangesRequest) returns (ActiveSetChanges) {
@@ -126,7 +126,7 @@ service BeaconChain {
// Retrieve the validator participation information for a given epoch.
//
// This method returns information about the global participation of
// This method returns information about the global participation of
// validator attestations.
rpc GetValidatorParticipation(GetValidatorParticipationRequest) returns (ValidatorParticipationResponse) {
option (google.api.http) = {
@@ -228,31 +228,42 @@ message BeaconBlockContainer {
bytes block_root = 2;
}
// Information about the head of the beacon chain.
message ChainHead {
// 32 byte merkle tree root of the canonical head block in the beacon node.
bytes block_root = 1 [(gogoproto.moretags) = "ssz-size:\"32\""];
bytes head_block_root = 1 [(gogoproto.moretags) = "ssz-size:\"32\""];
// Slot of the head block.
uint64 block_slot = 2;
uint64 head_block_slot = 2;
// Epoch of the head block.
uint64 head_block_epoch = 3;
// Most recent slot that contains the finalized block.
uint64 finalized_block_slot = 4;
// Epoch of the finalized block.
uint64 finalized_epoch = 5;
// Most recent finalized slot.
uint64 finalized_slot = 3;
// Most recent 32 byte finalized block root.
bytes finalized_block_root = 4 [(gogoproto.moretags) = "ssz-size:\"32\""];
bytes finalized_block_root = 6 [(gogoproto.moretags) = "ssz-size:\"32\""];
// Most recent justified slot.
uint64 justified_slot = 5;
// Most recent slot that contains the justified block.
uint64 justified_block_slot = 7;
// Epoch of the justified block.
uint64 justified_epoch = 8;
// Most recent 32 byte justified block root.
bytes justified_block_root = 6 [(gogoproto.moretags) = "ssz-size:\"32\""];
bytes justified_block_root = 9 [(gogoproto.moretags) = "ssz-size:\"32\""];
// Previous justified slot.
uint64 previous_justified_slot = 7;
// Most recent slot that contains the previous justified block.
uint64 previous_justified_slot = 10;
// Epoch of the previous justified block.
uint64 previous_justified_epoch = 11;
// Previous 32 byte justified block root.
bytes previous_justified_block_root = 8 [(gogoproto.moretags) = "ssz-size:\"32\""];
bytes previous_justified_block_root = 12 [(gogoproto.moretags) = "ssz-size:\"32\""];
}
message ListCommitteesRequest {

5
proto/eth/v1alpha1/node.pb.go generated
View File

@@ -6,13 +6,12 @@ package eth
import (
context "context"
fmt "fmt"
io "io"
math "math"
proto "github.com/gogo/protobuf/proto"
types "github.com/gogo/protobuf/types"
_ "google.golang.org/genproto/googleapis/api/annotations"
grpc "google.golang.org/grpc"
io "io"
math "math"
)
// Reference imports to suppress errors if they are not otherwise used.

5
proto/eth/v1alpha1/slasher.pb.go generated
View File

@@ -6,12 +6,11 @@ package eth
import (
context "context"
fmt "fmt"
io "io"
math "math"
proto "github.com/gogo/protobuf/proto"
types "github.com/gogo/protobuf/types"
grpc "google.golang.org/grpc"
io "io"
math "math"
)
// Reference imports to suppress errors if they are not otherwise used.

5
proto/eth/v1alpha1/validator.pb.go generated
View File

@@ -7,14 +7,13 @@ import (
context "context"
encoding_binary "encoding/binary"
fmt "fmt"
io "io"
math "math"
_ "github.com/gogo/protobuf/gogoproto"
proto "github.com/gogo/protobuf/proto"
types "github.com/gogo/protobuf/types"
_ "google.golang.org/genproto/googleapis/api/annotations"
grpc "google.golang.org/grpc"
io "io"
math "math"
)
// Reference imports to suppress errors if they are not otherwise used.

3
proto/sharding/p2p/v1/messages.pb.go generated
View File

@@ -5,10 +5,9 @@ package ethereum_sharding_p2p_v1
import (
fmt "fmt"
proto "github.com/gogo/protobuf/proto"
io "io"
math "math"
proto "github.com/gogo/protobuf/proto"
)
// Reference imports to suppress errors if they are not otherwise used.

16
tools/forkchecker/forkchecker.go
View File

@@ -89,8 +89,8 @@ func compareHeads(clients map[string]pb.BeaconChainClient) {
log.Fatal(err)
}
log.Infof("Comparing all heads for head slot :%d", head1.BlockSlot)
if (head1.BlockSlot+1)%params.BeaconConfig().SlotsPerEpoch == 0 {
log.Infof("Comparing all heads for head slot :%d", head1.HeadBlockSlot)
if (head1.HeadBlockSlot+1)%params.BeaconConfig().SlotsPerEpoch == 0 {
p, err := clients[endpt1].GetValidatorParticipation(context.Background(), &pb.GetValidatorParticipationRequest{})
if err != nil {
log.Fatal(err)
@@ -108,10 +108,10 @@ func compareHeads(clients map[string]pb.BeaconChainClient) {
logHead(endpt1, head1)
logHead(endpt2, head2)
if (head1.BlockSlot+1)%params.BeaconConfig().SlotsPerEpoch == 0 {
if (head1.HeadBlockSlot+1)%params.BeaconConfig().SlotsPerEpoch == 0 {
p, err := clients[endpt2].GetValidatorParticipation(context.Background(), &pb.GetValidatorParticipationRequest{
QueryFilter: &pb.GetValidatorParticipationRequest_Epoch{
Epoch: head2.BlockSlot / params.BeaconConfig().SlotsPerEpoch,
Epoch: head2.HeadBlockSlot / params.BeaconConfig().SlotsPerEpoch,
},
})
if err != nil {
@@ -126,11 +126,11 @@ func compareHeads(clients map[string]pb.BeaconChainClient) {
func logHead(endpt string, head *pb.ChainHead) {
log.WithFields(
logrus.Fields{
"HeadSlot": head.BlockSlot,
"HeadRoot": hex.EncodeToString(head.BlockRoot),
"JustifiedEpoch": head.JustifiedSlot / params.BeaconConfig().SlotsPerEpoch,
"HeadSlot": head.HeadBlockSlot,
"HeadRoot": hex.EncodeToString(head.HeadBlockRoot),
"JustifiedEpoch": head.JustifiedEpoch,
"JustifiedRoot": hex.EncodeToString(head.JustifiedBlockRoot),
"FinalizedEpoch": head.FinalizedSlot / params.BeaconConfig().SlotsPerEpoch,
"FinalizedEpoch": head.FinalizedEpoch,
"FinalizedRoot": hex.EncodeToString(head.FinalizedBlockRoot),
}).Info("Head from beacon node ", endpt)
}