Diverge link methods

[samtay]

I had merged the notions of referencing an existing message in SDLP and in ZKP. This doesn't make sense and also imposes unnecessarily limitations. This PR separates the two notions.

api

Essentially the API looks like this (with each one also having a corresponding symmetric version):

impl Builder {
    /// Encrypt a plaintext, adding the encryption statement to the proof.
    pub fn encrypt<P>(&mut self, message: &P, public_key: &'k PublicKey) -> Result<Ciphertext>
        where
            P: TryIntoPlaintext + TypeName;

    /// Encrypt a plaintext, adding the encryption statement to the proof and returning the
    /// message to optionally be [encrypted again](`Self::encrypt_again`), that is, _shared_
    /// with another proof statement.
    pub fn encrypt_and_share<P>(&mut self, message: &P, public_key: &'k PublicKey) -> Result<(Ciphertext, Message)>
        where
            P: TryIntoPlaintext + TypeName;

    /// Encrypt a plaintext intended for linking.
    ///
    /// The returned `LinkedMessage` can be used:
    /// 1. to add an encryption statement of ciphertext equality to the proof (see [`Self::encrypt_again`]).
    /// 2. as a linked input to a ZKP program (see [`Self::linked_input`]).
    pub fn encrypt_and_link<P>(&mut self, message: &P, public_key: &'k PublicKey) -> Result<(Ciphertext, LinkedMessage)>
        where
            P: LinkWithZkp + TryIntoPlaintext + TypeName;

    /// Encrypt an existing message, adding the new encryption statement to the proof.
    ///
    /// This method purposefully reveals that two ciphertexts encrypt the same underlying value. If
    /// this is not what you want, use [`Self::encrypt`].
    pub fn encrypt_again<E>(&mut self, message: &E, public_key: &'k PublicKey) -> Result<Ciphertext>
        where
            E: ExistingMessage;
}

other ideas

I played with some other ideas, like using a singular Message<T = ()> and type LinkedMessage = Message<Link> rather than the sealed ExistingMessage trait. We do use that pattern elsewhere so it wouldn't be inconsistent to do so, but in the end I thought above was simpler. I also considered always returning a Message from these methods, where Message can be converted into a ciphertext, but again thought it was not as clear as the above.

Let me know what you think regarding ExistingMessage vs Message<T>, I could go either way.

[ryanorendorff]

This is mostly bike shedding around which proof system is being referenced. Potentially we could call encrypt_and_share as encrypt_and_reuse_message and encrypt_and_link could be encrypt_and_send_to_zkp_program. I don't know if there is an awesome way to differentiate the two ZKP methods without making it confusing to the user that there are two, but maybe that is because we know too much 😆 .

[samtay]

Updated the naming to the following:

impl Builder {
    /// Encrypt a plaintext, adding the encryption statement to the logproof.
    pub fn encrypt<P>(&mut self, message: &P, public_key: &'k PublicKey) -> Result<Ciphertext>
        where
            P: TryIntoPlaintext + TypeName;

    /// Encrypt a plaintext, adding the encryption statement to the logproof and returning the
    /// message to optionally be [encrypted again](`Self::encrypt_again`), that is, _shared_
    /// with another proof statement.
    pub fn encrypt_returning_msg<P>(&mut self, message: &P, public_key: &'k PublicKey) -> Result<(Ciphertext, Message)>
        where
            P: TryIntoPlaintext + TypeName;

    /// Encrypt a plaintext intended for linking.
    ///
    /// The returned `LinkedMessage` can be used:
    /// 1. to add an encryption statement of ciphertext equality to the logproof (see [`Self::encrypt_again`]).
    /// 2. as a linked input to a ZKP program (see [`Self::linked_input`]).
    pub fn encrypt_returning_link<P>(&mut self, message: &P, public_key: &'k PublicKey) -> Result<(Ciphertext, LinkedMessage)>
        where
            P: LinkWithZkp + TryIntoPlaintext + TypeName;

    /// Encrypt an existing message, adding the new encryption statement to the logproof.
    ///
    /// This method purposefully reveals that two ciphertexts encrypt the same underlying value. If
    /// this is not what you want, use [`Self::encrypt`].
    pub fn encrypt_msg<E>(&mut self, message: &E, public_key: &'k PublicKey) -> Result<Ciphertext>
        where
            E: ExistingMessage;
}