protocol

type ADCNetConfig struct {
	// AuctionSlots is the number of slots in the IBLT for auction data.
	AuctionSlots uint32 `json:"auction_slots"`

	// MessageLength is the maximum byte capacity of the message vector.
	// Actual per-round length is determined by auction results.
	MessageLength int `json:"message_length"`

	// MinClients is the minimum number of clients for anonymity.
	MinClients uint32 `json:"min_clients"`

	// RoundDuration is the time duration of each protocol round.
	RoundDuration time.Duration `json:"round_duration,string"`

	// RoundsPerWindow defines rounds per participation window for rate limiting.
	RoundsPerWindow uint32 `json:"rounds_per_window"`
}

type AggregatedClientMessages struct {
	RoundNumber   int
	AllServerIds  []ServerID
	AuctionVector []*big.Int         // Sum of client auction vectors in field
	MessageVector []byte             // XOR of client message vectors
	UserPKs       []crypto.PublicKey // Public keys of contributing clients
}

type AggregatorMessager struct {
	Config *ADCNetConfig
}

type AggregatorRoundData struct {
	Round     int
	Aggregate *AggregatedClientMessages
}

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

type AuctionResult struct {
	// ShouldSend indicates if the client won a slot.
	ShouldSend bool

	// MessageStartIndex is the byte offset where the message should be placed.
	MessageStartIndex int

	// TotalAllocated indicates how many total bytes have been allocated by the auction
	TotalAllocated int
}

type ClientMessager struct {
	Config        *ADCNetConfig
	SharedSecrets map[ServerID]crypto.SharedKey
}

type ClientRoundMessage struct {
	RoundNumber   int
	AllServerIds  []ServerID
	AuctionVector []*big.Int // Field-blinded auction IBLT elements
	MessageVector []byte     // XOR-blinded message bytes
}

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

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

type PendingMessage struct {
	Message     []byte
	AuctionData *blind_auction.AuctionData
}

type Round struct {
	Number  int
	Context RoundContext
}

type RoundBroadcast struct {
	RoundNumber   int
	AuctionVector *blind_auction.IBLTVector
	MessageVector []byte
}

type RoundContext int

type RoundCoordinator interface {
	CurrentRound() Round
	SubscribeToRounds(ctx context.Context) <-chan Round
	Start(ctx context.Context)
	AdvanceToRound(round Round)
}

type ScheduledMessage struct {
	Message      []byte
	AuctionRound int // Round when the auction bid was submitted
}

type ServerID = crypto.ServerID

type ServerMessager struct {
	Config        *ADCNetConfig
	ServerID      ServerID
	SharedSecrets map[string]crypto.SharedKey
}

type ServerPartialDecryptionMessage struct {
	ServerID          ServerID
	OriginalAggregate *AggregatedClientMessages
	UserPKs           []crypto.PublicKey
	AuctionVector     []*big.Int // Server's auction blinding vector
	MessageVector     []byte     // Server's XOR blinding vector
}

type ServerRoundData struct {
	Round                           int
	ServerPartialDecryptionMessages map[ServerID]*ServerPartialDecryptionMessage
	PartialDecryptionMessage        *ServerPartialDecryptionMessage
	RoundOutput                     *RoundBroadcast
}

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

type Signed[T any] struct {
	PublicKey crypto.PublicKey `json:"public_key"`
	Signature crypto.Signature `json:"signature"`
	Object    *T               `json:"object"`
}

type VerifiedClientMessage struct {
	Message *ClientRoundMessage
	Signer  crypto.PublicKey
}