eth2api

type ApiError interface {
	error
	Code() uint
}

type ApiPeerId string

type AttesterDuty struct {
	Pubkey common.BLSPubkey `json:"pubkey"`
	// Index of validator in validator registry
	ValidatorIndex common.ValidatorIndex `json:"validator_index"`
	// The committee index
	CommitteeIndex common.CommitteeIndex `json:"committee_index"`
	// Number of validators in committee
	CommitteeLength view.Uint64View `json:"committee_length"`
	// Number of committees at the provided slot
	CommitteesAtSlot view.Uint64View `json:"committees_at_slot"`
	// Index of validator in committee
	ValidatorCommitteeIndex view.Uint64View `json:"validator_committee_index"`
	// The slot at which the validator must attest.
	Slot common.Slot `json:"slot"`
}

type BasicResponse struct {
	// contains filtered or unexported fields
}

type BeaconBlockHeaderAndInfo struct {
	Root      common.Root                    `json:"root"`
	Canonical bool                           `json:"canonical"`
	Header    common.SignedBeaconBlockHeader `json:"header"`
}

type BeaconCommitteeSubscribeSignal struct {
	ValidatorIndex common.ValidatorIndex `json:"validator_index"`
	CommitteeIndex common.CommitteeIndex `json:"committee_index"`
	// Number of committees at the returned slot
	CommitteesAtSlot view.Uint64View `json:"committees_at_slot"`
	// Should be slot at which validator is assigned to attest
	Slot common.Slot `json:"slot"`
	// Signals to BN that a validator on the VC has been chosen for aggregator role.
	IsAggregator view.BoolView `json:"is_aggregator"`
}

type BlockId interface {
	BlockId() string
}

type BlockIdRoot common.Root

type BlockIdSlot common.Slot

type BlockIdStrMode string

type ChainHead struct {
	Root common.Root `json:"root"`
	Slot common.Slot `json:"slot"`
}

type Client interface {
	Request(ctx context.Context, req PreparedRequest) Response
}

type ClientApiErr struct {
	// contains filtered or unexported fields
}

type ClientErr struct {
	// contains filtered or unexported fields
}

type ClientFunc func(ctx context.Context, req PreparedRequest) Response

type Codec interface {
	EncodeResponseBody(w io.Writer, data interface{}) error
	DecodeResponseBody(code uint, r io.ReadCloser, dest interface{}) error
	EncodeRequestBody(w io.Writer, body interface{}) error
	DecodeRequestBody(r io.ReadCloser, dst interface{}) error
	ContentType() []string
}

type Committee struct {
	// Committee index at a slot
	Index common.CommitteeIndex `json:"index"`

	// Slot the committee performs duties on
	Slot common.Slot `json:"slot"`

	// List of validator indices assigned to this committee
	Validators []common.ValidatorIndex `json:"validators"`
}

type ConnectionDirection string

type ConnectionState string

type DataWrap struct {
	Data interface{} `json:"data"`
}

type DependentAttesterDuties struct {
	// Duties are valid only on the chain with this given block root
	DependentRoot common.Root    `json:"dependent_root"`
	Data          []AttesterDuty `json:"data"`
}

type DependentProposerDuty struct {
	// Duties are valid only on the chain with this given block root
	DependentRoot common.Root    `json:"dependent_root"`
	Data          []ProposerDuty `json:"data"`
}

type DepositContractResponse struct {
	// Id of Eth1 chain on which contract is deployed.
	ChainID view.Uint64View `json:"chain_id"`
	// Hex encoded deposit contract address with 0x prefix
	Address common.Eth1Address `json:"address"`
}

type ErrorMessage struct {
	// Either specific error code in case of invalid request or http status code
	CodeValue uint `json:"code"`
	// Message describing error
	Message string `json:"message"`
	// Optional stacktraces, sent when node is in debug mode
	Stacktraces []string `json:"stacktraces,omitempty"`
	// Optional list of individual items that have failed
	Failures []IndexedErrorMessageItem `json:"failures,omitempty"`
}

type Eth2HttpClient struct {
	Addr  string
	Cli   HTTPClient
	Codec Codec
}

type FinalityCheckpoints struct {
	PreviousJustified common.Checkpoint `json:"previous_justified"`
	CurrentJustified  common.Checkpoint `json:"current_justified"`
	Finalized         common.Checkpoint `json:"finalized"`
}

type GenesisResponse struct {
	GenesisTime           common.Timestamp `json:"genesis_time"`
	GenesisValidatorsRoot common.Root      `json:"genesis_validators_root"`
	GenesisForkVersion    common.Version   `json:"genesis_fork_version"`
}

type HTTPClient interface {
	Do(req *http.Request) (*http.Response, error)
}

type HandlerFn func(ctx context.Context, req Request) PreparedResponse

type Headers map[string]string

type HttpResponse struct {
	*http.Response
	Codec Codec
}

type HttpRouter struct {
	httprouter.Router
	Codec         Codec
	OnEncodingErr func(error)
}

type IndexedError interface {
	IndexedErrors() []IndexedErrorMessageItem
}

type IndexedErrorMessageItem struct {
	// Index of item in the request list that caused the error
	Index uint `json:"index"`
	// Message describing error
	Message string `json:"message"`
}

type JSONCodec struct{}

type NetworkIdentity struct {
	PeerID ApiPeerId `json:"peer_id"`

	// Ethereum node record. [Read more](https://eips.ethereum.org/EIPS/eip-778)
	ENR string `json:"enr"`

	// Node's addresses on which eth2 rpc requests are served. [Read more](https://docs.libp2p.io/reference/glossary/#multiaddr)
	P2PAddresses []string `json:"p2p_addresses"`

	// Node's addresses on which is listening for discv5 requests. [Read more](https://docs.libp2p.io/reference/glossary/#multiaddr)
	DiscoveryAddresses []string `json:"discovery_addresses"`

	// Based on eth2 Metadata object
	Metadata common.MetaData `json:"metadata"`
}

type NodeVersionResponse struct {
	Version string `json:"version"`
}

type Peer struct {
	PeerID             ApiPeerId           `json:"peer_id"`
	ENR                string              `json:"enr"`
	LastSeenP2PAddress string              `json:"last_seen_p2p_address"`
	State              ConnectionState     `json:"state"`
	Direction          ConnectionDirection `json:"direction"`
}

type PeerCountResponse struct {
	Disconnected  view.Uint64View `json:"disconnected"`
	Connecting    view.Uint64View `json:"connecting"`
	Connected     view.Uint64View `json:"connected"`
	Disconnecting view.Uint64View `json:"disconnecting"`
}

type PlainGET string

type PreparedRequest interface {
	// The type of request
	Method() ReqMethod

	// Body, optional. Returns nil if no body. Only used for PUT/POST methods.
	Body() interface{}

	// Path to request, including any path variable contents
	Path() string

	// Query params to add to the request, may be nil
	Query() Query
}

type PreparedResponse interface {
	//
	Code() uint
	// body to encode as response, may be nil
	Body() interface{}
	// headers to put into the response, may be nil
	Headers() Headers
}

type ProposerDuty struct {
	Pubkey common.BLSPubkey `json:"pubkey"`
	// Index of validator in validator registry
	ValidatorIndex common.ValidatorIndex `json:"validator_index"`
	// The slot at which the validator must propose block.
	Slot common.Slot
}

type Query map[string]interface{}

type ReqMethod string

type Request interface {
	DecodeBody(dst interface{}) error
	Param(name string) string
	Query(name string) (values []string, ok bool)
}

type Response interface {
	// Decode into destination type. May throw a decoding error.
	// Or throws DecodeNoContentErr if it was an error without returned value.
	// Call with nil to just close the response contents.
	// May only be called once.
	Decode(dest interface{}) (code uint, err error)
}

type RootResponse struct {
	Root common.Root `json:"root"`
}

type Route interface {
	Method() ReqMethod
	Route() string
	Handle(ctx context.Context, req Request) PreparedResponse
}

type Server interface {
	AddRoute(handler Route)
}

type SignedBeaconBlock interface {
	beacon.OpaqueBlock
}

type StateId interface {
	StateId() string
}

type StateIdRoot common.Root

type StateIdSlot common.Slot

type StateIdStrMode string

type StatusFilter []ValidatorStatus

type SyncCommitteeDuty struct {
	Pubkey                        common.BLSPubkey      `json:"pubkey"`
	ValidatorIndex                common.ValidatorIndex `json:"validator_index"`
	ValidatorSyncCommitteeIndices []view.Uint64View     `json:"validator_sync_committee_indices"`
}

type SyncCommitteeSubscribeSignal struct {
	ValidatorIndex common.ValidatorIndex `json:"validator_index"`
	// positions of the validator-index relative to the complete sync committee (a validator can have multiple)
	SyncCommitteeIndices []view.Uint64View `json:"sync_committee_indices"`
	UntilEpoch           common.Epoch      `json:"until_epoch"`
}

type SyncCommittees struct {
	// All of the validator indices in the current sync committee
	Validators []common.ValidatorIndex `json:"validators"`
	// Subcommittee slices of the current sync committee
	ValidatorAggregates [][]common.ValidatorIndex `json:"validator_aggregates"`
}

type SyncingStatus struct {
	// Head slot node is trying to reach
	HeadSlot common.Slot `json:"head_slot"`
	// How many slots node needs to process to reach head. 0 if synced.
	SyncDistance common.Slot `json:"sync_distance"`
}

type ValidatorBalanceResponse struct {
	// Index of validator in validator registry.
	Index common.ValidatorIndex `json:"index"`

	// Current validator balance in gwei
	Balance common.Gwei `json:"balance"`
}

type ValidatorId interface {
	ValidatorId() string
}

type ValidatorIdFilter []ValidatorId

type ValidatorIdIndex common.ValidatorIndex

type ValidatorIdPubkey common.BLSPubkey

type ValidatorResponse struct {
	// Index of validator in validator registry.
	Index common.ValidatorIndex `json:"index"`
	// Current validator balance in gwei
	Balance common.Gwei `json:"balance"`
	// TODO
	Status ValidatorStatus `json:"status"`
	// The validator as defined in the registry in the BeaconState
	Validator phase0.Validator `json:"validator"`
}

type ValidatorStatus string

type VersionedBeaconBlock struct {
	Version string `json:"version"`
	// Data is *phase0.BeaconBlock, *altair.BeaconBlock,
	// *bellatrix.BeaconBlock or *sharding.BeaconBlock.
	Data common.SpecObj `json:"data"`
}

type VersionedBeaconState struct {
	Version string `json:"version"`
	// Data is *phase0.BeaconState, *altair.BeaconState, *bellatrix.BeaconState or *sharding.BeaconState.
	// See the Tree(spec) method to transform into a binary-tree backed state for advanced processing.
	Data common.SpecObj `json:"data"`
}

type VersionedSignedBeaconBlock struct {
	Version string `json:"version"`
	// Data is *phase0.SignedBeaconBlock, *altair.SignedBeaconBlock,
	// *bellatrix.SignedBeaconBlock or *sharding.SignedBeaconBlock.
	Data SignedBeaconBlock `json:"data"`
}