circuits

type Circuit func(Runtime) error

type Descriptor struct {
	Signature
	sessions.CircuitID
	NodeMapping map[string]sessions.NodeID // TODO: nil node mapping is identity mapping
	Evaluator   sessions.NodeID
}

type Event struct {
	EventType
	Descriptor
}

type EventType int8

type FutureOperand struct {
	Operand // TODO should hid this field to prevent user to access not-yet-set operands
	// contains filtered or unexported fields
}

type Input struct {
	OperandLabel
	OperandValue any
}

type Metadata struct {
	Descriptor
	InputSet, Ops, OutputSet utils.Set[OperandLabel]
	InputsFor, OutputsFor    map[sessions.NodeID]utils.Set[OperandLabel]
	KeySwitchOps             map[string]protocols.Signature
	NeedRlk                  bool
	GaloisKeys               utils.Set[uint64]
}

type Name string

type Operand struct {
	OperandLabel
	*rlwe.Ciphertext
}

type OperandLabel string

type Output struct {
	sessions.CircuitID
	Operand
}

type PublicKeyProvider interface {
	GetCollectivePublicKey(context.Context) (*rlwe.PublicKey, error)
	GetGaloisKey(ctx context.Context, galEl uint64) (*rlwe.GaloisKey, error)
	GetRelinearizationKey(context.Context) (*rlwe.RelinearizationKey, error)
}

type Runtime interface {
	CircuitDescriptor() Descriptor

	Parameters() sessions.FHEParameters

	// Input reads an input operand with the given label from the context.
	// When specifying the label, the user:
	//  - can use a placeholder id for the node, the mapping for which is provided in the Signature.
	//  - can omit the session-id part as it wil be automatically resolved by the runtime.
	Input(OperandLabel) *FutureOperand

	// InputSum reads a multiparty input operand with the given label from the context.
	// It is a special case of Input, where the input is a sum of multiple inputs from at least T parties,
	// where T is the session threshold.
	// When specifying the label, the user:
	//  - must not specify a node id; it will be automatically resolved by the runtime.
	//  - can omit the session-id part as it wil be automatically resolved by the runtime.
	// The node id list must be either empty or contain at least T node ids. An empty list is equivalent to
	// all the nodes in the session. Placeholder ids are allowed.
	InputSum(OperandLabel, ...sessions.NodeID) *FutureOperand

	// Load reads an existing ciphertext in the session
	// When specifying the label, the user:
	//  - can use a placeholder id for the node, the mapping for which is provided in the Signature.
	//  - can omit the session-id part as it wil be automatically resolved by the runtime.
	Load(OperandLabel) *Operand

	// NewOperand creates a new operand with the given label.
	// When specifying the label, the user:
	//  - can use a placeholder id for the node, the mapping for which is provided in the Signature.
	//  - can omit the session-id part as it wil be automatically resolved by the runtime.
	NewOperand(OperandLabel) *Operand

	// EvalLocal is used to perform local operation on the ciphertext. This is where the FHE computation
	// is performed. The user must specify the required evaluation keys needed by the function. The provided
	// function must not call any other Runtime function (ie., it must be  strictly local circuit).
	EvalLocal(needRlk bool, galKeys []uint64, f func(he.Evaluator) error) error

	// DEC performes the decryption of in, with private output to rec.
	// The decrypted operand is considered an output for the this circuit and the
	// given reciever.
	// It expect the users to provide the decryption parameters, including the level
	// at which the operation is performed and the smudging parameter.
	DEC(in Operand, rec sessions.NodeID, params map[string]string) error

	// PCKS performes the re-encryption of in to the public key of rec.
	// The the re-encrypted operand is considered an output for the this circuit and the
	// given reciever.
	// It expect the users to provide the key-switch parameters, including the level
	// at which the operation is performed and the smudging parameter.
	PCKS(in Operand, rec sessions.NodeID, params map[string]string) error

	// Logf logs a message with the given format and arguments.
	Logf(format string, args ...interface{})
}

type Signature struct {
	Name
	Args map[string]string
}

type TestRuntime struct {
	sessions.TestSession
	// contains filtered or unexported fields
}