Struct ElGamalEncryptedNote

pub struct ElGamalEncryptedNote<const N: usize> {
    pub encrypted_values: [Base; N],
    pub ephem_public: PublicKey,
}

An encrypted note using an ElGamal scheme verifiable in ZK.

WARNING: Without ZK, there is no authentication of the ciphertexts so these should not be used without a corresponding ZK proof.

Fields

encrypted_values: [Base; N]

The values encrypted with the derived shared secret using Diffie-Hellman

ephem_public: PublicKey

The ephemeral public key used for Diffie-Hellman key derivation

Implementations

impl<const N: usize> ElGamalEncryptedNote<N>

pub fn encrypt_unsafe( values: [Base; N], ephem_secret: &SecretKey, public: &PublicKey, ) -> Result<Self, ContractError>

Encrypt given values to the given PublicKey using a SecretKey for Diffie-Hellman

Note that this does not do any message authentication. This means that alterations of the ciphertexts lead to the same alterations on the plaintexts.

pub fn decrypt_unsafe( &self, secret: &SecretKey, ) -> Result<[Base; N], ContractError>

Decrypt the ElGamalEncryptedNote using a SecretKey for shared secret derivation using Diffie-Hellman

Note that this does not do any message authentication. This means that alterations of the ciphertexts lead to the same alterations on the plaintexts.

Trait Implementations

impl<const N: usize> AsyncDecodable for ElGamalEncryptedNote<N>

where [Base; N]: AsyncDecodable, PublicKey: AsyncDecodable,

fn decode_async<'life0, 'async_trait, D>( d: &'life0 mut D, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where D: 'async_trait + AsyncRead + Unpin + Send, Self: 'async_trait, 'life0: 'async_trait,

impl<const N: usize> AsyncEncodable for ElGamalEncryptedNote<N>

where [Base; N]: AsyncEncodable, PublicKey: AsyncEncodable,

fn encode_async<'life0, 'life1, 'async_trait, S>( &'life0 self, s: &'life1 mut S, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where S: 'async_trait + AsyncWrite + Unpin + Send, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Asynchronously encode an object with a well-defined format. Should only ever error if the underlying AsyncWrite errors. Returns the number of bytes written on success.

impl<const N: usize> Clone for ElGamalEncryptedNote<N>

fn clone(&self) -> ElGamalEncryptedNote<N>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<const N: usize> Debug for ElGamalEncryptedNote<N>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<const N: usize> Decodable for ElGamalEncryptedNote<N>

where [Base; N]: Decodable, PublicKey: Decodable,

fn decode<D: Read>(d: &mut D) -> Result<Self, Error>

impl<const N: usize> Encodable for ElGamalEncryptedNote<N>

where [Base; N]: Encodable, PublicKey: Encodable,

fn encode<S: Write>(&self, s: &mut S) -> Result<usize, Error>

Encode an object with a well-defined format. Should only ever error if the underlying Write errors. Returns the number of bytes written on success.

impl<const N: usize> PartialEq for ElGamalEncryptedNote<N>

fn eq(&self, other: &ElGamalEncryptedNote<N>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const N: usize> Copy for ElGamalEncryptedNote<N>

impl<const N: usize> Eq for ElGamalEncryptedNote<N>

impl<const N: usize> StructuralPartialEq for ElGamalEncryptedNote<N>