bootstrap

type AuthorizationController interface {
	component.Initer

	Authorize(ctx context.Context, discoveryNode *DiscoveryNode, cert core.AuthorizationCertificate) (SessionID, error)
	Register(ctx context.Context, discoveryNode *DiscoveryNode, sessionID SessionID) error
}

type AuthorizationRequest struct {
	Certificate []byte
}

type AuthorizationResponse struct {
	Code      OperationCode
	Error     string
	SessionID SessionID
}

type Bootstrapper interface {
	component.Initer

	Bootstrap(ctx context.Context) (*network.BootstrapResult, *DiscoveryNode, error)
	BootstrapDiscovery(ctx context.Context) (*network.BootstrapResult, error)
	SetLastPulse(number core.PulseNumber)
	GetLastPulse() core.PulseNumber
}

type ChallengePayload struct {
	// CurrentPulse  core.Pulse
	// State         core.NetworkState
	AssignShortID core.ShortNodeID
}

type ChallengeRequest struct {
	SessionID SessionID

	Nonce Nonce
}

type ChallengeResponse struct {
	Header  ChallengeResponseHeader
	Payload *ChallengePayload
}

type ChallengeResponseController interface {
	component.Initer

	Execute(ctx context.Context, discoveryNode *DiscoveryNode, sessionID SessionID) (*ChallengePayload, error)
}

type ChallengeResponseHeader struct {
	Success bool
	Error   string
}

type Code uint8

type DiscoveryNode struct {
	Host *host.Host
	Node core.DiscoveryNode
}

type GenesisRequest struct {
	LastPulse core.PulseNumber
	Discovery *NodeStruct
}

type GenesisResponse struct {
	Response GenesisRequest
	Error    string
}

type NetworkBootstrapper interface {
	Bootstrap(ctx context.Context) (*network.BootstrapResult, error)
	SetLastPulse(number core.PulseNumber)
	GetLastPulse() core.PulseNumber
}

type NodeBootstrapRequest struct{}

type NodeBootstrapResponse struct {
	Code         Code
	RedirectHost string
	RejectReason string
}

type NodeStruct struct {
	ID      core.RecordRef
	SID     core.ShortNodeID
	Role    core.StaticRole
	PK      []byte
	Address string
	Version string
}

type Nonce []byte

type OperationCode uint8

type RegistrationRequest struct {
	SessionID SessionID
	Version   string
	JoinClaim *packets.NodeJoinClaim
}

type RegistrationResponse struct {
	Code    OperationCode
	RetryIn time.Duration
	Error   string
}

type Session struct {
	NodeID core.RecordRef
	Cert   core.AuthorizationCertificate
	State  SessionState

	DiscoveryNonce Nonce

	Time time.Time
	TTL  time.Duration
}

type SessionID uint64

type SessionManager interface {
	component.Starter
	component.Stopper

	NewSession(ref core.RecordRef, cert core.AuthorizationCertificate, ttl time.Duration) SessionID
	CheckSession(id SessionID, expected SessionState) error
	SetDiscoveryNonce(id SessionID, discoveryNonce Nonce) error
	GetChallengeData(id SessionID) (core.AuthorizationCertificate, Nonce, error)
	ChallengePassed(id SessionID) error
	ReleaseSession(id SessionID) (*Session, error)
	ProlongateSession(id SessionID, session *Session)
}

type SessionState uint8

type SignedChallengePayload struct {
	SignedNonce       SignedNonce
	XorDiscoveryNonce Nonce
	DiscoveryNonce    Nonce
}

type SignedChallengeRequest struct {
	SessionID SessionID

	SignedDiscoveryNonce SignedNonce
	XorNonce             Nonce
}

type SignedChallengeResponse struct {
	Header  ChallengeResponseHeader
	Payload *SignedChallengePayload
}

type SignedNonce []byte

type StartSessionRequest struct{}

type StartSessionResponse struct {
	SessionID SessionID
}