types

type AggregatorCalls interface {
	// SignSlotWithSelectionProof signs slot for aggregator selection proof
	SignSlotWithSelectionProof(slot spec.Slot, pk []byte) (Signature, []byte, error)
	// SignAggregateAndProof returns a signed aggregate and proof msg
	SignAggregateAndProof(msg *spec.AggregateAndProof, duty *Duty, pk []byte) (*spec.SignedAggregateAndProof, []byte, error)
}

type AttesterCalls interface {
	// SignAttestation signs the given attestation
	SignAttestation(data *spec.AttestationData, duty *Duty, pk []byte) (*spec.Attestation, []byte, error)
	// IsAttestationSlashable returns error if attestation is slashable
	IsAttestationSlashable(data *spec.AttestationData) error
}

type BeaconNetwork string

type BeaconRole int

type BeaconSigner interface {
	AttesterCalls
	ProposerCalls
	AggregatorCalls
	SyncCommitteeCalls
	SyncCommitteeContributionCalls
}

type ConsensusData struct {
	Duty                   *Duty
	AttestationData        *phase0.AttestationData
	BlockData              *altair.BeaconBlock
	AggregateAndProof      *phase0.AggregateAndProof
	SyncCommitteeBlockRoot phase0.Root
	// SyncCommitteeContribution map holds as key the selection proof for the contribution
	SyncCommitteeContribution ContributionsMap
}

type ContributionsMap map[phase0.BLSSignature]*altair.SyncCommitteeContribution

type DKGSigner interface {
	SSVSigner
	// SignDKGOutput signs output according to the SIP https://docs.google.com/document/d/1TRVUHjFyxINWW2H9FYLNL2pQoLy6gmvaI62KL_4cREQ/edit
	SignDKGOutput(output Root, address common.Address) (Signature, error)
	// SignETHDepositRoot signs an ethereum deposit root
	SignETHDepositRoot(root []byte, address common.Address) (Signature, error)
}

type DomainType []byte

type Duty struct {
	// Type is the duty type (attest, propose)
	Type BeaconRole
	// PubKey is the public key of the validator that should attest.
	PubKey spec.BLSPubKey
	// Slot is the slot in which the validator should attest.
	Slot spec.Slot
	// ValidatorIndex is the index of the validator that should attest.
	ValidatorIndex spec.ValidatorIndex
	// CommitteeIndex is the index of the committee in which the attesting validator has been placed.
	CommitteeIndex spec.CommitteeIndex
	// CommitteeLength is the length of the committee in which the attesting validator has been placed.
	CommitteeLength uint64
	// CommitteesAtSlot is the number of committees in the slot.
	CommitteesAtSlot uint64
	// ValidatorCommitteeIndex is the index of the validator in the list of validators in the committee.
	ValidatorCommitteeIndex uint64
}

type Encoder interface {
	// Encode returns the encoded struct in bytes or error
	Encode() ([]byte, error)
	// Decode returns error if decoding failed
	Decode(data []byte) error
}

type EncryptionCalls interface {
	// Decrypt given a rsa pubkey and a PKCS1v15 cipher text byte array, returns the decrypted data
	Decrypt(pk *rsa.PublicKey, cipher []byte) ([]byte, error)
	// Encrypt given a rsa pubkey and data returns an PKCS1v15 encrypted cipher
	Encrypt(pk *rsa.PublicKey, data []byte) ([]byte, error)
}

type KeyManager interface {
	BeaconSigner
	SSVSigner
	// AddShare saves a share key
	AddShare(shareKey *bls.SecretKey) error
}

type MessageID [52]byte

type MessageSignature interface {
	Root
	GetSignature() Signature
	GetSigners() []OperatorID
	// MatchedSigners returns true if the provided signer ids are equal to GetSignerIds() without order significance
	MatchedSigners(ids []OperatorID) bool
	// Aggregate will aggregate the signed message if possible (unique signers, same digest, valid)
	Aggregate(signedMsg MessageSignature) error
}

type MsgType uint64

type Operator struct {
	OperatorID OperatorID
	PubKey     []byte
}

type OperatorID uint64

type ProposerCalls interface {
	// SignRandaoReveal signs randao
	SignRandaoReveal(epoch spec.Epoch, pk []byte) (Signature, []byte, error)
	// IsBeaconBlockSlashable returns true if the given block is slashable
	IsBeaconBlockSlashable(block *altair.BeaconBlock) error
	// SignBeaconBlock signs the given beacon block
	SignBeaconBlock(block *altair.BeaconBlock, duty *Duty, pk []byte) (*altair.SignedBeaconBlock, []byte, error)
}

type Root interface {
	// GetRoot returns the root used for signing and verification
	GetRoot() ([]byte, error)
}

type SSVMessage struct {
	MsgType MsgType
	MsgID   MessageID
	Data    []byte
}

type SSVSigner interface {
	EncryptionCalls
	SignRoot(data Root, sigType SignatureType, pk []byte) (Signature, error)
}

type Share struct {
	OperatorID            OperatorID
	ValidatorPubKey       ValidatorPK
	SharePubKey           []byte
	Committee             []*Operator
	Quorum, PartialQuorum uint64
	DomainType            DomainType
	Graffiti              []byte
}

type Signature []byte

type SignatureDomain []byte

type SignatureType [4]byte

type SyncCommitteeCalls interface {
	// SignSyncCommitteeBlockRoot returns a signed sync committee msg
	SignSyncCommitteeBlockRoot(slot spec.Slot, root spec.Root, validatorIndex spec.ValidatorIndex, pk []byte) (*altair.SyncCommitteeMessage, []byte, error)
}

type SyncCommitteeContributionCalls interface {
	// SignContributionProof signs contribution proof
	SignContributionProof(slot spec.Slot, index uint64, pk []byte) (Signature, []byte, error)
	// SignContribution signs a SyncCommitteeContribution
	SignContribution(contribution *altair.ContributionAndProof, pk []byte) (*altair.SignedContributionAndProof, []byte, error)
}

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

type Validate interface {
	// Validate returns error if msg validation doesn't pass.
	// Msg validation checks the msg, it's variables for validity.
	Validate() error
}

type ValidatorPK []byte