crypto

type AggregateSigner interface {
	Signer

	// GetVerifierFactory returns the factory that can deserialize verifiers of
	// the same type as the signer.
	GetVerifierFactory() VerifierFactory

	// Aggregate returns the aggregate signature of the ones in parameter.
	Aggregate(signatures ...Signature) (Signature, error)
}

type CollectiveAuthority interface {
	mino.Players

	// GetPublicKey returns the public key and its index of the corresponding
	// address if any matches. An index < 0 means no correspondance found.
	GetPublicKey(addr mino.Address) (PublicKey, int)

	// PublicKeyIterator creates a public key iterator that iterates over the
	// list of public keys and is consistent with the address iterator.
	PublicKeyIterator() PublicKeyIterator
}

type CryptographicRandomGenerator struct{}

type HashAlgorithm int

type HashFactory interface {
	New() hash.Hash
}

type PublicKey interface {
	encoding.BinaryMarshaler
	encoding.TextMarshaler
	serde.Message

	// Verify returns nil if the signature matches the message, otherwise an
	// error is returned.
	Verify(msg []byte, signature Signature) error

	// Equal returns true when both objects are similar.
	Equal(other interface{}) bool
}

type PublicKeyFactory interface {
	serde.Factory

	// PublicKeyOf populates the public key associated to the data if
	// appropriate, otherwise it returns an error.
	PublicKeyOf(ctx serde.Context, data []byte) (PublicKey, error)

	// FromBytes returns the public key associated to the data if appropriate,
	// otherwise it returns an error.
	FromBytes(data []byte) (PublicKey, error)
}

type PublicKeyIterator interface {
	// Seek moves the iterator to a specific index.
	Seek(int)

	// HasNext returns true if a public key is available, false if the iterator
	// is exhausted.
	HasNext() bool

	// GetNext returns the next public key in case HasNext returns true,
	// otherwise no assumption can be done.
	GetNext() PublicKey
}

type RandGenerator interface {
	// Read populates the buffer with random bytes up to a size that is
	// returned alongside an error if something goes wrong.
	Read([]byte) (int, error)
}

type Signature interface {
	encoding.BinaryMarshaler
	serde.Message

	// Equal returns true if both objects are similar.
	Equal(other Signature) bool
}

type SignatureFactory interface {
	serde.Factory

	// SignatureOf returns a signature associated with the data if appropriate,
	// otherwise it returns an error.
	SignatureOf(ctx serde.Context, data []byte) (Signature, error)
}

type Signer interface {
	// GetPublicKeyFactory returns a factory that can deserialize public keys of
	// the same type as the signer.
	GetPublicKeyFactory() PublicKeyFactory

	// GetSignatureFactory returns a factory that can deserialize signatures of
	// the same type as the signer.
	GetSignatureFactory() SignatureFactory

	// GetPublicKey returns the public key of the signer.
	GetPublicKey() PublicKey

	// Sign returns a signature that will match the message for the signer
	// public key.
	Sign(msg []byte) (Signature, error)
}

type Verifier interface {
	// Verify returns nil if the signature matches the message for the public
	// key internal to the verifier.
	Verify(msg []byte, signature Signature) error
}

type VerifierFactory interface {
	// FromAuthority returns a verifier that will use the authority to generate
	// a public key.
	FromAuthority(ca CollectiveAuthority) (Verifier, error)

	// FromArray returns a verifier that will use the list of public keys to
	// generate one.
	FromArray(keys []PublicKey) (Verifier, error)
}