pki

type Chunker struct {
	ChunkSize int
	Total     int
}

type Dechunker struct {
	ChunkNum   int
	ChunkTotal int
	Chunks     *bytes.Buffer
	Output     []byte
}

type Deserializer interface {
	Deserialize(raw []byte) (*Document, error)
}

type Document struct {
	// Epoch is the epoch for which this Document instance is valid for.
	Epoch uint64

	// GenesisEpoch is the epoch on which authorities started consensus
	GenesisEpoch uint64

	// SendRatePerMinute is the number of packets per minute a client can send.
	SendRatePerMinute uint64

	// Mu is the inverse of the mean of the exponential distribution
	// that the Sphinx packet per-hop mixing delay will be sampled from.
	Mu float64

	// MuMaxDelay is the maximum Sphinx packet per-hop mixing delay in
	// milliseconds.
	MuMaxDelay uint64

	// LambdaP is the inverse of the mean of the exponential distribution
	// that clients will sample to determine the time interval between sending
	// messages from it's FIFO egress queue or drop decoy messages if the queue
	// is empty.
	LambdaP float64

	// LambdaPMaxDelay is the maximum time interval in milliseconds.
	LambdaPMaxDelay uint64

	// LambdaL is the inverse of the mean of the exponential distribution
	// that clients will sample to determine the time interval between sending
	// decoy loop messages.
	LambdaL float64

	// LambdaLMaxDelay is the maximum time interval in milliseconds.
	LambdaLMaxDelay uint64

	// LambdaD is the inverse of the mean of the exponential distribution
	// that clients will sample to determine the time interval between sending
	// decoy drop messages.
	LambdaD float64

	// LambdaDMaxDelay is the maximum time interval in milliseconds.
	LambdaDMaxDelay uint64

	// LambdaM is the inverse of the mean of the exponential distribution
	// that mixes will sample to determine send timing of mix loop decoy traffic.
	LambdaM float64

	// LambdaMMaxDelay is the maximum send interval in milliseconds.
	LambdaMMaxDelay uint64

	// LambdaG is the inverse of the mean of the exponential distribution
	// that mixes will sample to determine send timing of gateway node loop decoy traffic.
	LambdaG float64

	// LambdaGMaxDelay is the maximum send interval in milliseconds.
	LambdaGMaxDelay uint64

	// LambdaR is the inverse of the mean of the exponential distribution
	// that the courier and storage replicas will sample to determine the
	// send timing of decoy traffic between each other.
	LambdaR float64

	// LambdaRMaxDelay is the maximum send interval in milliseconds.
	LambdaRMaxDelay uint64

	// Topology is the mix network topology, excluding providers.
	Topology [][]*MixDescriptor

	// GatewayNodes is the list of nodes that can allow clients to interact
	// with the mix network.
	GatewayNodes []*MixDescriptor

	// ServiceNodes is the list of nodes that can allow services to interact
	// with tehe mix network.
	ServiceNodes []*MixDescriptor

	// StorageReplicas is the list of Storage Replica nodes that do not talk over the mixnet
	// but are expected to handle connections from the Service Nodes and the other replicas.
	StorageReplicas []*ReplicaDescriptor

	// ConfiguredReplicaIDs is the complete set of ReplicaIDs configured for this network.
	// This set is stable and does not change when replicas go offline.
	// It is used for consistent sharding so that shard assignments remain stable
	// even when replicas are temporarily unavailable.
	ConfiguredReplicaIDs []uint8 `cbor:"ConfiguredReplicaIDs,omitempty"`

	// ConfiguredReplicaIdentityKeys is the complete set of identity public keys
	// for all configured replicas. This set is stable and does not change when replicas
	// go offline. It is used for consistent hashing to determine shard assignments.
	ConfiguredReplicaIdentityKeys [][]byte `cbor:"ConfiguredReplicaIdentityKeys,omitempty"`

	// ReplicaEnvelopeKeys contains envelope public keys for all configured replicas,
	// indexed by ReplicaID and then by replica epoch. This map includes keys from
	// replicas that are temporarily offline, using cached values from previous epochs.
	// It contains keys for the previous, current, and next replica epochs.
	ReplicaEnvelopeKeys map[uint8]map[uint64][]byte `cbor:"ReplicaEnvelopeKeys,omitempty"`

	// Signatures holds detached Signatures from deserializing a signed Document
	Signatures map[[PublicKeyHashSize]byte]cert.Signature `cbor:"-"`

	// SharedRandomCommit used by the voting process.
	SharedRandomCommit map[[PublicKeyHashSize]byte][]byte

	// SharedRandomReveal used by the voting process.
	SharedRandomReveal map[[PublicKeyHashSize]byte][]byte

	// SharedRandomValue produced by voting process.
	SharedRandomValue []byte

	// PriorSharedRandom used by applications that need a longer lived SRV.
	PriorSharedRandom [][]byte

	// SphinxGeometryHash is used to ensure all mixnet actors have the same
	// Sphinx Geometry.
	SphinxGeometryHash []byte

	// Version uniquely identifies the document format as being for the
	// specified version so that it can be rejected if the format changes.
	Version string

	// PKISignatureScheme specifies the cryptographic signature scheme
	PKISignatureScheme string
}

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

type FetchDocumentResult struct {
	Epoch   uint64
	Doc     *Document
	RawDoc  []byte
	Error   error
	Skipped bool
}

type Fetcher interface {
	GetPKIDocumentForEpoch(ctx context.Context, epoch uint64) (*Document, []byte, error)
}

type MixDescriptor struct {
	// Name is the human readable (descriptive) node identifier.
	Name string

	// Epoch is the Epoch in which this descriptor was created
	Epoch uint64

	// IdentityKey is the node's identity (signing) key.
	IdentityKey []byte

	// LinkKey is the node's wire protocol public key.
	LinkKey []byte

	// MixKeys is a map of epochs to Sphinx keys.
	MixKeys map[uint64][]byte

	// Addresses is the map of transport to address combinations that can
	// be used to reach the node.
	Addresses map[string][]string

	// Kaetzchen is the map of provider autoresponder agents by capability
	// to parameters.
	Kaetzchen map[string]map[string]interface{}

	// KaetzchenAdvertizedData is used by the operator to advertize
	// additional information about specific services. This is different
	// from the above Kaetzchen map in that these keys will never be
	// modified or passed over commandline to the plugin.
	KaetzchenAdvertizedData map[string]map[string]interface{}

	// IsGatewayNode indicates that this Mix is a gateway node.
	// Essentially a gateway allows clients to interact with the mixnet.
	// This option being set to true is mutually exclusive with
	// `IsServiceNode` being set to true.
	IsGatewayNode bool

	// IsServiceNode indicates that this Mix is a service node.
	// Service nodes run services which the mixnet interacts with.
	IsServiceNode bool

	// LoadWeight is the node's load balancing weight (unused).
	LoadWeight uint8

	// AuthenticationType is the authentication mechanism required
	AuthenticationType string

	// Version uniquely identifies the descriptor format as being for the
	// specified version so that it can be rejected if the format changes.
	Version string
}

type MixDescriptorPoster interface {
	Post(ctx context.Context, epoch uint64, signingPrivateKey sign.PrivateKey, signingPublicKey sign.PublicKey, d *MixDescriptor, loopstats *loops.LoopStats) error
}

type MixNodeClient interface {
	Fetcher
	MixDescriptorPoster
}

type PostingClient interface {
	Fetcher
	Deserializer
	MixDescriptorPoster
	ReplicaDescriptorPoster
}

type ReplicaDescriptor struct {
	// Name is the unique name of the pigeonhole storage replica.
	Name string

	// ReplicaID is the static uint8 identifier for this replica.
	// All dirauths and replicas must agree on this value.
	ReplicaID uint8

	// Epoch is the Epoch in which this descriptor was created
	Epoch uint64

	// IdentityKey is the node's identity (signing) key.
	IdentityKey []byte

	// LinkKey is our PQ Noise Public Key.
	LinkKey []byte

	// EnvelopeKeys is mapping from Replica Epoch ID to Public NIKE Key used with our MKEM scheme.
	EnvelopeKeys map[uint64][]byte

	// Addresses is the map of transport to address combinations that can
	// be used to reach the node.
	Addresses map[string][]string
}

type ReplicaDescriptorPoster interface {
	PostReplica(ctx context.Context, epoch uint64, signingPrivateKey sign.PrivateKey, signingPublicKey sign.PublicKey, d *ReplicaDescriptor) error
}

type ReplicaNodeClient interface {
	Fetcher
	ReplicaDescriptorPoster
}

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

type SignedReplicaUpload struct {
	// Signature is the signature over the serialized SignedReplicaUpload.
	Signature *cert.Signature

	// ReplicaDescriptor is the replica descriptor.
	ReplicaDescriptor *ReplicaDescriptor
}

type SignedUpload struct {
	// Signature is the signature over the serialized SignedUpload.
	Signature *cert.Signature

	// MixDescriptor is the mix descriptor.
	MixDescriptor *MixDescriptor

	// LoopStats is the mix loop statistics.
	LoopStats *loops.LoopStats
}

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