network

type BlockdataHandler func(string) (io.Reader, func() error, error)

type BlockdataMapsHandler func([]base.Height) ([]block.BlockdataMap, error)

type Channel interface {
	util.Initializer
	ConnInfo() ConnInfo
	StagedOperations(context.Context, []valuehash.Hash) ([]operation.Operation, error)
	SendSeal(context.Context, ConnInfo, seal.Seal) error
	Proposal(context.Context, valuehash.Hash) (base.Proposal, error)
	NodeInfo(context.Context) (NodeInfo, error)
	BlockdataMaps(context.Context, []base.Height) ([]block.BlockdataMap, error)
	Blockdata(context.Context, block.BlockdataMapItem) (io.ReadCloser, error)
	StartHandover(context.Context, StartHandoverSeal) (bool, error)
	PingHandover(context.Context, PingHandoverSeal) (bool, error)
	EndHandover(context.Context, EndHandoverSeal) (bool, error)
}

type ConnInfo interface {
	hint.Hinter
	isvalid.IsValider
	fmt.Stringer
	util.Byter
	URL() *url.URL
	Insecure() bool
	Equal(ConnInfo) bool
}

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

type EndHandoverHandler func(EndHandoverSeal) (bool, error)

type EndHandoverSeal interface {
	HandoverSeal
}

type GetProposalHandler func(valuehash.Hash) (base.Proposal, error)

type GetStagedOperationsHandler func([]valuehash.Hash) ([]operation.Operation, error)

type GetStateHandler func(string) (state.State, bool, error)

type HTTPConnInfo struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

type HTTPConnInfoPackerJSON struct {
	jsonenc.HintedHead
	U string `json:"url"`
	I bool   `json:"insecure"`
}

type HTTPConnInfoUnpackerBSON struct {
	HT hint.Hint `bson:"_hint"`
	U  string    `bson:"url"`
	I  bool      `bson:"insecure"`
}

type HTTPConnInfoUnpackerJSON struct {
	U string `json:"url"`
	I bool   `json:"insecure"`
}

type HTTPHandlerFunc func(http.ResponseWriter, *http.Request)

type HandoverSeal interface {
	seal.Seal
	Address() base.Address
	ConnInfo() ConnInfo
}

type HandoverSealV0 struct {
	seal.BaseSeal
	// contains filtered or unexported fields
}

type HandoverSealV0BSONUnpack struct {
	AD base.AddressDecoder `bson:"address"`
	CI bson.Raw            `bson:"conninfo"`
}

type HandoverSealV0JSONPack struct {
	*seal.BaseSealJSONPack
	AD base.Address `json:"address"`
	CI ConnInfo     `json:"conninfo"`
}

type HandoverSealV0JSONUnpack struct {
	AD base.AddressDecoder `json:"address"`
	CI json.RawMessage     `json:"conninfo"`
}

type NewSealHandler func(seal.Seal) error

type NilConnInfo struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

type NilConnInfoPackerJSON struct {
	jsonenc.HintedHead
	S string `json:"name"`
}

type NilConnInfoUnpackerBSON struct {
	HT hint.Hint `bson:"_hint"`
	S  string    `bson:"name"`
}

type NilConnInfoUnpackerJSON struct {
	S string `json:"name"`
}

type NodeInfo interface {
	isvalid.IsValider
	hint.Hinter
	base.Node
	NetworkID() base.NetworkID
	State() base.State
	LastBlock() block.Manifest
	Version() util.Version
	ConnInfo() ConnInfo
	Policy() map[string]interface{}
	Nodes() []RemoteNode // Only contains suffrage nodes
}

type NodeInfoChecker struct {
	sync.RWMutex
	*logging.Logging
	*util.ContextDaemon
	// contains filtered or unexported fields
}

type NodeInfoHandler func() (NodeInfo, error)

type NodeInfoV0 struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

type NodeInfoV0PackerJSON struct {
	jsonenc.HintedHead
	ND  base.Node              `json:"node"`
	NID base.NetworkID         `json:"network_id"`
	ST  base.State             `json:"state"`
	LB  block.Manifest         `json:"last_block"`
	VS  util.Version           `json:"version"`
	PO  map[string]interface{} `json:"policy"`
	SF  []RemoteNode           `json:"suffrage"`
	CI  ConnInfo               `json:"conninfo"`
}

type NodeInfoV0UnpackerBSON struct {
	ND  bson.Raw               `bson:"node"`
	NID base.NetworkID         `bson:"network_id"`
	ST  base.State             `bson:"state"`
	LB  bson.Raw               `bson:"last_block"`
	VS  util.Version           `bson:"version"`
	PO  map[string]interface{} `bson:"policy"`
	SF  []bson.Raw             `bson:"suffrage"`
	CI  bson.Raw               `bson:"conninfo"`
}

type NodeInfoV0UnpackerJSON struct {
	ND  json.RawMessage        `json:"node"`
	NID base.NetworkID         `json:"network_id"`
	ST  base.State             `json:"state"`
	LB  json.RawMessage        `json:"last_block"`
	VS  util.Version           `json:"version"`
	PO  map[string]interface{} `json:"policy"`
	SF  []json.RawMessage      `json:"suffrage"`
	CI  json.RawMessage        `json:"conninfo"`
}

type Nodepool struct {
	*logging.Logging
	sync.RWMutex
	// contains filtered or unexported fields
}

type PassthroughedSeal struct {
	seal.Seal
	// contains filtered or unexported fields
}

type PingHandoverHandler func(PingHandoverSeal) (bool, error)

type PingHandoverSeal interface {
	HandoverSeal
}

type Problem struct {
	hint.BaseHinter
	// contains filtered or unexported fields
}

type ProblemJSONPacker struct {
	jsonenc.HintedHead
	T  string                 `json:"type"`
	TI string                 `json:"title"`
	DE string                 `json:"detail,omitempty"`
	EX map[string]interface{} `json:"extra,omitempty"`
}

type RemoteNode struct {
	Address   base.Address
	Publickey key.Publickey
	// contains filtered or unexported fields
}

type RemoteNodeUnpackBSON struct {
	A  base.AddressDecoder  `bson:"address"`
	P  key.PublickeyDecoder `bson:"publickey"`
	CI bson.Raw             `bson:"conninfo"`
}

type RemoteNodeUnpackJSON struct {
	A  base.AddressDecoder  `json:"address"`
	P  key.PublickeyDecoder `json:"publickey"`
	CI json.RawMessage      `json:"conninfo"`
}

type Response interface {
	util.Byter
	OK() bool
}

type Server interface {
	util.Daemon
	util.Initializer
	SetNewSealHandler(NewSealHandler)
	SetGetStagedOperationsHandler(GetStagedOperationsHandler)
	SetGetProposalHandler(GetProposalHandler)
	NodeInfoHandler() NodeInfoHandler
	SetNodeInfoHandler(NodeInfoHandler)
	SetBlockdataMapsHandler(BlockdataMapsHandler)
	SetBlockdataHandler(BlockdataHandler)
	SetStartHandoverHandler(StartHandoverHandler)
	SetPingHandoverHandler(PingHandoverHandler)
	SetEndHandoverHandler(EndHandoverHandler)
}

type StartHandoverHandler func(StartHandoverSeal) (bool, error)

type StartHandoverSeal interface {
	HandoverSeal
}